GODOT IS OPEN SOURCE

18 files changed, 15831 insertions, 0 deletions

diff --git a/servers/visual/SCsub b/servers/visual/SCsub
new file mode 100644
index 0000000000..16fe3a59ac
--- /dev/null
+++ b/servers/visual/SCsub
@@ -0,0 +1,7 @@
+Import('env')
+
+env.add_source_files(env.servers_sources,"*.cpp")
+
+Export('env')
+
+
diff --git a/servers/visual/default_mouse_cursor.xpm b/servers/visual/default_mouse_cursor.xpm
new file mode 100644
index 0000000000..37d437dd15
--- /dev/null
+++ b/servers/visual/default_mouse_cursor.xpm
@@ -0,0 +1,23 @@
+/* XPM */
+static const char * default_mouse_cursor_xpm[] = {
+"16 16 4 1",
+" 	c None",
+".	c #000000",
+"+	c #FF00FF",
+"@	c #FFFFFF",
+"...+++++++++++++",
+".@...+++++++++++",
+".@@@...+++++++++",
+".@@@@@....++++++",
+".@@@@@@@@...++++",
+".@@@@@@@@@@...++",
+".@@@@@@@@@@@@..+",
+".@@@@@@@@@@@@@..",
+".@@@@@@@@@@@@..+",
+".@@@@@@@@@@@..++",
+".@@@@@@@@@...+++",
+".@@@.....@@..+++",
+".....+++.@@@..++",
+"++++++++..@@@..+",
+"+++++++++..@@@.+",
+"++++++++++.....+"};
diff --git a/servers/visual/particle_system_sw.cpp b/servers/visual/particle_system_sw.cpp
new file mode 100644
index 0000000000..49a68f8e80
--- /dev/null
+++ b/servers/visual/particle_system_sw.cpp
@@ -0,0 +1,412 @@
+/*************************************************************************/
+/*  particle_system_sw.cpp                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "particle_system_sw.h"
+#include "sort.h"
+
+
+ParticleSystemSW::ParticleSystemSW() {
+
+	amount=8;
+	emitting=true;
+	
+	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;
+
+	height_from_velocity=false;
+	local_coordinates=false;
+
+	particle_vars[VS::PARTICLE_INITIAL_ANGLE]=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;
+
+}
+
+
+ParticleSystemSW::~ParticleSystemSW()
+{
+}
+
+
+#define DEFAULT_SEED 1234567
+
+_FORCE_INLINE_ static float _rand_from_seed(uint32_t *seed) {
+
+	uint32_t k;
+	uint32_t s = (*seed);
+	if (s == 0)
+		s = 0x12345987;
+	k = s / 127773;
+	s = 16807 * (s - k * 127773) - 2836 * k;
+	if (s < 0)
+		s += 2147483647;
+	(*seed) = s;
+	
+	float v=((float)((*seed) & 0xFFFFF))/(float)0xFFFFF;
+	v=v*2.0-1.0;
+	return v;
+}
+
+_FORCE_INLINE_ static uint32_t _irand_from_seed(uint32_t *seed) {
+
+	uint32_t k;
+	uint32_t s = (*seed);
+	if (s == 0)
+		s = 0x12345987;
+	k = s / 127773;
+	s = 16807 * (s - k * 127773) - 2836 * k;
+	if (s < 0)
+		s += 2147483647;
+	(*seed) = s;
+
+	return s;
+}
+
+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);
+	}
+	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);
+	}
+	float lifetime = p_system->particle_vars[VS::PARTICLE_LIFETIME];
+	if (lifetime<CMP_EPSILON) {
+		ERR_EXPLAIN("Particle system lifetime too small.");
+		ERR_FAIL_COND(lifetime<CMP_EPSILON);
+	}
+	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();
+
+	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;
+	}
+
+	float next_time = particle_system_time+p_time;
+	
+	if (next_time > lifetime)
+		next_time=Math::fmod(next_time,lifetime);
+		
+
+	ParticleData *pdata=&particle_data[0];
+	Vector3 attractor_positions[VS::MAX_PARTICLE_ATTRACTORS];
+
+	for(int i=0;i<p_system->attractor_count;i++) {
+
+		attractor_positions[i]=p_transform.xform(p_system->attractors[i].pos);
+	}
+
+
+	for(int i=0;i<particle_count;i++) {
+	
+		ParticleData &p=pdata[i];
+		
+		float restart_time = (i * lifetime / p_system->amount);
+		
+		bool restart=false;
+		
+		if ( next_time < particle_system_time ) {
+
+			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 (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) );
+					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) ) );
+				} else {
+					//use preset positions
+					if (p_system->local_coordinates)
+						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] );
+				}
+							
+				
+				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);
+
+				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_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);
+
+			} else {
+			
+				p.pos=Vector3();
+				p.rot=0;
+				p.vel=Vector3();
+				p.active=false;
+			}
+		
+		} else {
+		
+			if (!p.active)
+				continue;
+
+			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]));
+			//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]);
+			//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]);
+			//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]);
+			//apply attractor forces
+			for(int a=0;a<p_system->attractor_count;a++) {
+
+				force+=(p.pos-attractor_positions[a]).normalized() * p_system->attractors[a].force;
+			}
+
+
+			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();
+				} else {
+					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;
+		}
+	}
+
+	particle_system_time=Math::fmod( particle_system_time+p_time, lifetime );
+
+
+}
+
+ParticleSystemProcessSW::ParticleSystemProcessSW() {
+
+	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 {
+
+		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) {
+
+	ERR_FAIL_COND(p_process->particle_data.size() != p_system->amount);
+	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];
+
+	ParticleSystemSW::ColorPhase cphase[VS::MAX_PARTICLE_COLOR_PHASES];
+
+	float last=-1;
+	int col_count=0;
+
+	for(int i=0;i<p_system->color_phase_count;i++) {
+
+		if (p_system->color_phases[i].pos<=last)
+			break;
+		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++) {
+
+		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.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;
+		else
+			time=(1.0-time)+time_pos;
+
+		Vector3 up=p_camera_transform.basis.get_axis(1); // up determines the rotation
+		float up_scale=1.0;
+
+		if (p_system->height_from_velocity) {
+
+			Vector3 veld = pdi.data->vel;
+			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];
+				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]);
+
+
+				up_scale=Math::lerp(1.0,h,(1.0-vc));
+			}
+
+		} else if (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_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];
+			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);
+		}
+
+
+
+		int cpos=0;
+
+		while(cpos<col_count) {
+
+			if (cphase[cpos].pos > time)
+				break;
+			cpos++;
+		}
+
+		cpos--;
+
+
+		if (cpos==-1)
+			pdi.color=Color(1,1,1,1);
+		else {
+			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 );
+				else
+					pdi.color=cphase[cpos+1].color;
+			}
+		}
+
+
+		draw_info_order[i]=&pdi;
+
+	}
+
+
+	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
new file mode 100644
index 0000000000..2b18c7f4e3
--- /dev/null
+++ b/servers/visual/particle_system_sw.h
@@ -0,0 +1,131 @@
+/*************************************************************************/
+/*  particle_system_sw.h                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef PARTICLE_SYSTEM_SW_H
+#define PARTICLE_SYSTEM_SW_H
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+
+#include "servers/visual_server.h"
+
+struct ParticleSystemSW {
+	enum {
+	
+		MAX_PARTICLES=1024
+	};
+
+	float particle_vars[VS::PARTICLE_VAR_MAX];
+	float particle_randomness[VS::PARTICLE_VAR_MAX];
+	
+	Vector3 emission_half_extents;
+	DVector<Vector3> emission_points;
+	Vector3 gravity_normal;
+	Vector3 emission_base_velocity;
+	int amount;
+	bool emitting;
+	bool height_from_velocity;
+	AABB visibility_aabb;
+	bool sort;
+	bool local_coordinates;
+			
+	struct ColorPhase {
+		
+		float pos;
+		Color color;
+		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;
+		float force;
+	};
+	
+	int attractor_count;
+	Attractor attractors[VS::MAX_PARTICLE_ATTRACTORS];
+
+
+	ParticleSystemSW();	
+	~ParticleSystemSW();
+
+};
+
+
+struct ParticleSystemProcessSW {
+
+	enum {
+		PARTICLE_RANDOM_NUMBERS = 8,
+	};
+
+	struct ParticleData {
+			
+		Vector3 pos;
+		Vector3 vel;
+		float rot;
+		bool active;
+		float random[PARTICLE_RANDOM_NUMBERS];
+
+		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);
+
+	ParticleSystemProcessSW();
+};
+
+struct ParticleSystemDrawInfoSW {
+
+	struct ParticleDrawInfo {
+
+		const ParticleSystemProcessSW::ParticleData *data;
+		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);
+
+};
+
+#endif
diff --git a/servers/visual/rasterizer.cpp b/servers/visual/rasterizer.cpp
new file mode 100644
index 0000000000..2de49d3d81
--- /dev/null
+++ b/servers/visual/rasterizer.cpp
@@ -0,0 +1,573 @@
+/*************************************************************************/
+/*  rasterizer.cpp                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "rasterizer.h"
+#include "print_string.h"
+#include "os/os.h"
+
+RID Rasterizer::create_default_material() {
+
+	return material_create();
+}
+
+
+/* Fixed MAterial SHADER API */
+
+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);
+
+	if (E) {
+		E->get().refcount++;
+		return E->get().shader;
+	}
+
+	uint64_t t = OS::get_singleton()->get_ticks_usec();
+
+	FixedMaterialShader fms;
+	fms.refcount=1;
+	fms.shader=shader_create();
+
+	//create shader code
+
+
+	int texcoords_used=0;
+	String code;
+
+	static const char* _uv_str[4]={"UV","UV2","uv_xform","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";
+	}
+
+
+	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 (texcoords_used&(1<<VS::FIXED_MATERIAL_TEXCOORD_UV_TRANSFORM)) {
+
+		code+="uniform mat4 fmp_uv_xform;\n";
+		code+="vec2 uv_xform = fmp_uv_xform * UV;\n";
+	}
+
+	/* HANDLE NORMAL MAPPING */
+
+
+	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";
+		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
+		} else {
+			uv_str=_TEXUVSTR(VS::FIXED_MATERIAL_PARAM_NORMAL);
+		}
+		scode+="vec3 normal=tex( fmp_normal_tex,"+uv_str+").xyz * 2.0 - vec3(1.0,1.0,1.0);\n";
+		scode+="NORMAL = mix( NORMAL,mat3(TANGENT,BINORMAL,NORMAL) * normal,  fmp_normal);\n";
+		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)) {
+
+		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;
+	}
+
+	/* HANDLE DIFFUSE LIGHTING */
+
+	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+="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)) {
+
+		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";
+
+		switch(p_key.detail_blend) {
+
+			case VS::MATERIAL_BLEND_MODE_MIX:
+
+				dcode+="diffuse=vec4(mix(diffuse.rgb,detail.rgb,detail.a*fmp_detail),diffuse.a);\n";
+			break;
+			case VS::MATERIAL_BLEND_MODE_ADD:
+				dcode+="diffuse=vec4(diffuse.rgb+detail.rgb*fmp_detail,diffuse.a);\n";
+			break;
+			case VS::MATERIAL_BLEND_MODE_SUB:
+				dcode+="diffuse=vec4(diffuse.rgb+detail.rgb*fmp_detail,diffuse.a);\n";
+			break;
+			case VS::MATERIAL_BLEND_MODE_MUL:
+				dcode+="diffuse=diffuse*mix(vec4(1,1,1,1),detail,fmp_detail);\n";
+			break;
+		}
+
+		code+=dcode;
+	}
+
+	if (p_key.use_alpha) {
+		code+="DIFFUSE_ALPHA=diffuse;\n";
+	} else {
+		code+="DIFFUSE=diffuse.rgb;\n";
+	}
+
+	/* HANDLE SPECULAR LIGHTING */
+
+	code+="uniform color fmp_specular;\n";
+	code+="color specular=fmp_specular;\n";
+
+	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;
+	}
+
+	code+="SPECULAR=specular.rgb;\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)) {
+
+		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;
+	}
+
+	code+="SPEC_EXP=specular_exp;\n";
+
+	/* HANDLE EMISSION LIGHTING */
+
+	code+="uniform color fmp_emission;\n";
+	code+="color emission=fmp_emission;\n";
+
+	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;
+	}
+
+	code+="EMISSION=emission.rgb;\n";
+
+
+	/* HANDLE GLOW */
+
+	code+="uniform float fmp_glow;\n";
+	code+="float glow=fmp_glow;\n";
+
+	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;
+	}
+
+	code+="GLOW=glow;\n";
+
+	//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";
+	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";
+	}
+
+	//print_line("**VERTEX SHADER GENERATED code: \n"+vcode);
+
+	double tf = (OS::get_singleton()->get_ticks_usec()-t)/1000.0;
+//	print_line("generate: "+rtos(tf));
+
+	shader_set_code(fms.shader,vcode,code,0,0);
+
+	fixed_material_shaders[p_key]=fms;
+	return fms.shader;
+}
+
+void Rasterizer::_free_shader(const FixedMaterialShaderKey& p_key) {
+
+	if (p_key.valid==0)
+		return; //not a valid key
+
+	Map<FixedMaterialShaderKey,FixedMaterialShader>::Element *E=fixed_material_shaders.find(p_key);
+
+	ERR_FAIL_COND(!E);
+	E->get().refcount--;
+	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);
+	ERR_FAIL_COND(!E);
+	FixedMaterial &fm=*E->get();
+
+	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;
+	}
+
+	if (!fm.dirty_list.in_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) {
+
+		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;
+	}
+
+
+	return false;
+}
+
+
+RID Rasterizer::fixed_material_create() {
+
+	RID mat = material_create();
+	fixed_materials[mat]=memnew( FixedMaterial() );
+	FixedMaterial &fm=*fixed_materials[mat];
+	fm.self=mat;
+	fm.get_key();
+	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
+	}
+	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){
+
+	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);
+
+	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");
+			ERR_FAIL();
+		}
+	} else {
+
+		if (!p_value.is_num()) {
+			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);
+
+
+}
+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());
+	return fm.param[p_parameter];
+}
+
+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);
+	if (!E) {
+
+		print_line("Not found: "+itos(p_material.get_id()));
+	}
+	ERR_FAIL_COND(!E);
+	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);
+
+	if (!fm.dirty_list.in_list())
+		fixed_material_dirty_list.add( &fm.dirty_list );
+
+
+
+
+}
+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());
+
+	return fm.texture[p_parameter];
+}
+
+void Rasterizer::fixed_material_set_detail_blend_mode(RID p_material,VS::MaterialBlendMode p_mode){
+
+	Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND(!E);
+	FixedMaterial &fm=*E->get();
+
+
+	fm.get_key();
+	ERR_FAIL_INDEX(p_mode,4);
+	fm.detail_blend=p_mode;
+	if (!fm.dirty_list.in_list())
+		fixed_material_dirty_list.add( &fm.dirty_list );
+
+}
+VS::MaterialBlendMode Rasterizer::fixed_material_get_detail_blend_mode(RID p_material) const{
+
+	const Map<RID,FixedMaterial*>::Element *E = fixed_materials.find(p_material);
+	ERR_FAIL_COND_V(!E,VS::MATERIAL_BLEND_MODE_MIX);
+	const FixedMaterial &fm=*E->get();
+
+	return fm.detail_blend;
+}
+
+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);
+	ERR_FAIL_COND(!E);
+	FixedMaterial &fm=*E->get();
+	ERR_FAIL_INDEX(p_parameter,VS::FIXED_MATERIAL_PARAM_MAX);
+
+	fm.get_key();
+
+	fm.texture_tc[p_parameter]=p_mode;
+
+	if (!fm.dirty_list.in_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 {
+
+	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) {
+
+	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_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();
+
+	return fm.uv_xform;
+}
+
+void Rasterizer::fixed_material_set_point_size(RID p_material,float p_size) {
+
+	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;
+
+
+}
+
+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();
+
+	return fm.point_size;
+
+}
+
+void Rasterizer::_update_fixed_materials() {
+
+
+	while(fixed_material_dirty_list.first()) {
+
+		FixedMaterial &fm=*fixed_material_dirty_list.first()->self();
+
+		FixedMaterialShaderKey new_key = fm.get_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);
+
+			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]);
+			}
+			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_uv_xform_name,fm.uv_xform);
+			if (fm.use_pointsize)
+				material_set_param(fm.self,_fixed_material_point_size_name,fm.point_size);
+		}
+
+		fixed_material_dirty_list.remove(fixed_material_dirty_list.first());
+	}
+}
+
+
+void Rasterizer::_free_fixed_material(const RID& 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);
+		memdelete(E->get());
+		fixed_materials.erase(E); //free material
+	}
+
+
+}
+
+
+void Rasterizer::flush_frame() {
+
+	//not really necesary to implement
+}
+
+Rasterizer::Rasterizer() {
+
+	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++) {
+
+		_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";
+
+}
+
+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 );
+
+
+	return mat;
+}
diff --git a/servers/visual/rasterizer.h b/servers/visual/rasterizer.h
new file mode 100644
index 0000000000..83031e981a
--- /dev/null
+++ b/servers/visual/rasterizer.h
@@ -0,0 +1,562 @@
+/*************************************************************************/
+/*  rasterizer.h                                                         */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef RASTERIZER_H
+#define RASTERIZER_H
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+#include "servers/visual_server.h"
+#include "camera_matrix.h"
+#include "map.h"
+#include "self_list.h"
+
+class Rasterizer {
+protected:
+
+	RID create_default_material();
+	RID create_overdraw_debug_material();
+
+
+	/* Fixed Material Shader API */
+
+	union FixedMaterialShaderKey {
+
+		struct {
+			uint16_t texcoord_mask;
+			uint8_t texture_mask;
+			uint8_t detail_blend:2;
+			bool use_alpha:1;
+			bool use_color_array:1;
+			bool use_pointsize:1;
+			bool valid:1;
+		};
+
+		uint32_t key;
+
+		_FORCE_INLINE_ bool operator<(const FixedMaterialShaderKey& p_key) const { return key<p_key.key; }
+	};
+
+	struct FixedMaterialShader {
+
+		int refcount;
+		RID shader;
+	};
+
+	Map<FixedMaterialShaderKey,FixedMaterialShader> fixed_material_shaders;
+
+	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;
+		bool use_pointsize;
+		float point_size;
+		Transform uv_xform;
+		VS::MaterialBlendMode detail_blend;
+		RID texture[VS::FIXED_MATERIAL_PARAM_MAX];
+		Variant param[VS::FIXED_MATERIAL_PARAM_MAX];
+		VS::FixedMaterialTexCoordMode texture_tc[VS::FIXED_MATERIAL_PARAM_MAX];
+
+		SelfList<FixedMaterial> dirty_list;
+
+		FixedMaterialShaderKey current_key;
+
+		_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.detail_blend=detail_blend;
+			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);
+				}
+			}
+
+			return k;
+		}
+
+
+		FixedMaterial() : dirty_list(this) {
+
+			use_alpha=false;
+			use_color_array=false;
+			use_pointsize=false;
+			point_size=1.0;
+			detail_blend=VS::MATERIAL_BLEND_MODE_MIX;
+			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;
+
+
+		}
+	};
+
+	StringName _fixed_material_param_names[VS::FIXED_MATERIAL_PARAM_MAX];
+	StringName _fixed_material_tex_names[VS::FIXED_MATERIAL_PARAM_MAX];
+	StringName _fixed_material_uv_xform_name;
+	StringName _fixed_material_point_size_name;
+
+	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);
+
+public:
+	/* 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 void texture_set_reload_hook(RID p_texture,ObjectID p_owner,const StringName& p_function) const=0;
+
+	/* SHADER API */
+
+	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_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs=0,int p_fragment_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 void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const=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 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_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_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled)=0;
+	virtual bool material_get_hint(RID p_material,VS::MaterialHint p_hint) const=0;
+
+	virtual void material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model)=0;
+	virtual VS::MaterialShadeModel material_get_shade_model(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 */
+
+	virtual RID fixed_material_create();
+
+	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_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_detail_blend_mode(RID p_material,VS::MaterialBlendMode p_mode);
+	virtual VS::MaterialBlendMode fixed_material_get_detail_blend_mode(RID p_material) 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 Transform fixed_material_get_uv_transform(RID p_material) const;
+
+	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 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_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_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 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) const=0;
+
+	/* MULTIMESH API */
+
+	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_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 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;
+
+	
+	/* PARTICLES API */
+	
+	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_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_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_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_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_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_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_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_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 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;
+
+	/* 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;
+
+	
+	/* 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 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_volumetric(RID p_light,bool p_enabled)=0;
+	virtual bool light_is_volumetric(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_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_operator(RID p_light,VS::LightOp p_op)=0;
+	virtual VS::LightOp light_get_operator(RID p_light) 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_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 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,
+		SHADOW_SIMPLE,
+		SHADOW_ORTHOGONAL,
+		SHADOW_DUAL_PARABOLOID,
+		SHADOW_CUBE,
+		SHADOW_PSSM, //parallel split shadow map
+		SHADOW_PSM //perspective shadow map
+	};
+	
+	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,	
+	};
+
+	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;
+
+	/* 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
+
+	/* 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;
+	
+	/* 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 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 set_viewport(const VS::ViewportRect& p_viewport)=0;
+	virtual void set_render_target(RID p_render_target)=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 set_camera(const Transform& p_world,const CameraMatrix& p_projection)=0;
+	
+	virtual void add_light( RID p_light_instance )=0; ///< all "add_light" calls happen before add_geometry calls
+	
+	typedef Map<StringName,Variant> ParamOverrideMap;
+
+
+	struct InstanceData {
+
+		Transform transform;
+		RID skeleton;
+		RID material_override;
+		Vector<RID> light_instances;
+		Vector<float> morph_values;
+		bool mirror :8;
+		bool depth_scale :8;
+		bool billboard :8;
+		bool billboard_y :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_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_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
+	};
+		
+	virtual void canvas_begin()=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, 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;
+	
+	/* ENVIRONMENT */
+	
+
+	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_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_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;
+
+		
+	/*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_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 void free(const RID& p_rid)=0;
+
+	virtual void init()=0;
+	virtual void finish()=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 int get_render_info(VS::RenderInfo p_info)=0;
+
+	Rasterizer();
+	virtual ~Rasterizer() {}
+};
+
+
+
+#endif
diff --git a/servers/visual/rasterizer_dummy.cpp b/servers/visual/rasterizer_dummy.cpp
new file mode 100644
index 0000000000..694d365d79
--- /dev/null
+++ b/servers/visual/rasterizer_dummy.cpp
@@ -0,0 +1,1786 @@
+/*************************************************************************/
+/*  rasterizer_dummy.cpp                                                 */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "rasterizer_dummy.h"
+
+/* TEXTURE API */
+
+
+RID RasterizerDummy::texture_create() {
+
+	Texture *texture = memnew(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) {
+
+
+	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;
+}
+
+void RasterizerDummy::texture_set_data(RID p_texture,const Image& p_image,VS::CubeMapSide p_cube_side) {
+
+	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;
+
+}
+
+Image RasterizerDummy::texture_get_data(RID p_texture,VS::CubeMapSide p_cube_side) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	ERR_FAIL_COND_V(!texture,Image());
+
+	return texture->image[p_cube_side];
+}
+
+void RasterizerDummy::texture_set_flags(RID p_texture,uint32_t p_flags) {
+
+	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
+
+}
+uint32_t RasterizerDummy::texture_get_flags(RID p_texture) const {
+
+	Texture * texture = texture_owner.get(p_texture);
+
+	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);
+
+	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);
+
+	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);
+
+	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);
+
+	ERR_FAIL_COND_V(!texture,0);
+
+	return false;
+
+}
+
+void RasterizerDummy::texture_set_size_override(RID p_texture,int p_width, int p_height) {
+
+	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);
+	//real texture size is in alloc width and 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 {
+
+
+}
+
+/* SHADER API */
+
+/* SHADER API */
+
+RID RasterizerDummy::shader_create(VS::ShaderMode p_mode) {
+
+	Shader *shader = memnew( Shader );
+	shader->mode=p_mode;
+	shader->fragment_line=0;
+	shader->vertex_line=0;
+	RID rid = shader_owner.make_rid(shader);
+
+	return rid;
+
+}
+
+
+
+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_COND(!shader);
+	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);
+	return shader->mode;
+}
+
+
+
+void RasterizerDummy::shader_set_code(RID p_shader, const String& p_vertex, const String& p_fragment,int p_vertex_ofs,int p_fragment_ofs) {
+
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+	shader->fragment_code=p_fragment;
+	shader->vertex_code=p_vertex;
+	shader->fragment_line=p_fragment_ofs;
+	shader->vertex_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());
+	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());
+	return shader->fragment_code;
+
+}
+
+void RasterizerDummy::shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const {
+
+	Shader *shader=shader_owner.get(p_shader);
+	ERR_FAIL_COND(!shader);
+
+}
+
+/* COMMON MATERIAL API */
+
+
+RID RasterizerDummy::material_create() {
+
+	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;
+
+}
+
+RID RasterizerDummy::material_get_shader(RID p_material) const {
+
+	Material *material = material_owner.get(p_material);
+	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) {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND(!material);
+
+	if (p_value.get_type()==Variant::NIL)
+		material->shader_params.erase(p_param);
+	else
+		material->shader_params[p_param]=p_value;
+}
+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());
+
+	if (material->shader_params.has(p_param))
+		return material->shader_params[p_param];
+	else
+		return Variant();
+}
+
+
+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;
+
+}
+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);
+	return material->flags[p_flag];
+
+
+}
+
+void RasterizerDummy::material_set_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled) {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND(!material);
+	ERR_FAIL_INDEX(p_hint,VS::MATERIAL_HINT_MAX);
+	material->hints[p_hint]=p_enabled;
+
+}
+
+bool RasterizerDummy::material_get_hint(RID p_material,VS::MaterialHint p_hint) const {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND_V(!material,false);
+	ERR_FAIL_INDEX_V(p_hint,VS::MATERIAL_HINT_MAX,false);
+	return material->hints[p_hint];
+
+}
+
+void RasterizerDummy::material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model) {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND(!material);
+	material->shade_model=p_model;
+
+};
+
+VS::MaterialShadeModel RasterizerDummy::material_get_shade_model(RID p_material) const {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND_V(!material,VS::MATERIAL_SHADE_MODEL_LAMBERT);
+	return material->shade_model;
+};
+
+
+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;
+
+}
+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);
+	return material->blend_mode;
+}
+
+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;
+
+}
+float RasterizerDummy::material_get_line_width(RID p_material) const {
+
+	Material *material = material_owner.get(p_material);
+	ERR_FAIL_COND_V(!material,0);
+
+	return material->line_width;
+}
+
+/* MESH API */
+
+
+RID RasterizerDummy::mesh_create() {
+
+
+	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) {
+
+	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);
+
+	Surface s;
+
+
+	s.format=0;
+
+	for(int i=0;i<p_arrays.size();i++) {
+
+		if (p_arrays[i].get_type()==Variant::NIL)
+			continue;
+
+		s.format|=(1<<i);
+
+		if (i==VS::ARRAY_VERTEX) {
+
+			Vector3Array v = p_arrays[i];
+			int len = v.size();
+			ERR_FAIL_COND(len==0);
+			Vector3Array::Read r = v.read();
+
+
+			for(int i=0;i<len;i++) {
+
+				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
+
+	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;
+
+	mesh->surfaces.push_back(surface);
+
+
+}
+
+
+
+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 {
+
+	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() );
+
+	return surface->data;
+
+
+}
+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() );
+	Surface *surface = mesh->surfaces[p_surface];
+	ERR_FAIL_COND_V( !surface, Array() );
+
+	return surface->morph_data;
+
+}
+
+
+void RasterizerDummy::mesh_set_morph_target_count(RID p_mesh,int p_amount) {
+
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_COND( mesh->surfaces.size()!=0 );
+
+	mesh->morph_target_count=p_amount;
+
+}
+
+int RasterizerDummy::mesh_get_morph_target_count(RID p_mesh) const{
+
+	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) {
+
+	ERR_FAIL_INDEX(p_mode,2);
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND(!mesh);
+
+	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);
+
+	return mesh->morph_target_mode;
+
+}
+
+
+
+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 );
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_surface, mesh->surfaces.size() );
+	Surface *surface = mesh->surfaces[p_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;
+}
+
+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() );
+	Surface *surface = mesh->surfaces[p_surface];
+	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 );
+	Surface *surface = mesh->surfaces[p_surface];
+	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 );
+	Surface *surface = mesh->surfaces[p_surface];
+	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 );
+	Surface *surface = mesh->surfaces[p_surface];
+	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 );
+	Surface *surface = mesh->surfaces[p_surface];
+	ERR_FAIL_COND_V( !surface, VS::PRIMITIVE_POINTS );
+
+	return surface->primitive;
+}
+
+void RasterizerDummy::mesh_remove_surface(RID p_mesh,int p_index) {
+
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND(!mesh);
+	ERR_FAIL_INDEX(p_index, mesh->surfaces.size() );
+	Surface *surface = mesh->surfaces[p_index];
+	ERR_FAIL_COND( !surface);
+
+	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);
+
+	return mesh->surfaces.size();
+}
+
+AABB RasterizerDummy::mesh_get_aabb(RID p_mesh) const {
+
+	Mesh *mesh = mesh_owner.get( p_mesh );
+	ERR_FAIL_COND_V(!mesh,AABB());
+
+	AABB aabb;
+
+	for (int i=0;i<mesh->surfaces.size();i++) {
+
+		if (i==0)
+			aabb=mesh->surfaces[i]->aabb;
+		else
+			aabb.merge_with(mesh->surfaces[i]->aabb);
+	}
+
+	return aabb;
+}
+
+/* MULTIMESH API */
+
+RID RasterizerDummy::multimesh_create() {
+
+	return multimesh_owner.make_rid( memnew( MultiMesh ));
+}
+
+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);
+
+	return multimesh->elements.size();
+}
+
+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;
+
+}
+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;
+}
+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;
+
+}
+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;
+
+}
+
+RID RasterizerDummy::multimesh_get_mesh(RID p_multimesh) const {
+
+	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
+	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());
+
+	return multimesh->aabb;
+}
+
+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_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 {
+
+	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
+	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) {
+
+	MultiMesh *multimesh = multimesh_owner.get(p_multimesh);
+	ERR_FAIL_COND(!multimesh);
+	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);
+	return multimesh->visible;
+
+}
+
+
+/* PARTICLES API */
+
+RID RasterizerDummy::particles_create() {
+
+	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(!particles);
+	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);
+	return particles->data.amount;
+
+}
+
+void RasterizerDummy::particles_set_emitting(RID p_particles, bool p_emitting) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	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);
+	return particles->data.emitting;
+
+}
+
+void RasterizerDummy::particles_set_visibility_aabb(RID p_particles, const AABB& p_visibility) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	particles->data.visibility_aabb=p_visibility;
+
+}
+
+void RasterizerDummy::particles_set_emission_half_extents(RID p_particles, const Vector3& p_half_extents) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+
+	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());
+
+	return particles->data.emission_half_extents;
+}
+
+void RasterizerDummy::particles_set_emission_base_velocity(RID p_particles, const Vector3& p_base_velocity) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+
+	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());
+
+	return particles->data.emission_base_velocity;
+}
+
+
+void RasterizerDummy::particles_set_emission_points(RID p_particles, const DVector<Vector3>& p_points) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+
+	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>());
+
+	return particles->data.emission_points;
+
+}
+
+void RasterizerDummy::particles_set_gravity_normal(RID p_particles, const Vector3& p_normal) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+
+	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());
+
+	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());
+	return particles->data.visibility_aabb;
+
+}
+
+void RasterizerDummy::particles_set_variable(RID p_particles, VS::ParticleVariable p_variable,float p_value) {
+
+	ERR_FAIL_INDEX(p_variable,VS::PARTICLE_VAR_MAX);
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	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);
+	return particles->data.particle_vars[p_variable];
+}
+
+void RasterizerDummy::particles_set_randomness(RID p_particles, VS::ParticleVariable p_variable,float p_randomness) {
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	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);
+	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 );
+	ERR_FAIL_COND(!particles);
+	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);
+	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;
+
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	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);
+	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) {
+
+	ERR_FAIL_INDEX(p_phase, VS::MAX_PARTICLE_COLOR_PHASES);
+	Particles* particles = particles_owner.get( p_particles );
+	ERR_FAIL_COND(!particles);
+	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;
+	}
+
+}
+
+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());
+	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 );
+	ERR_FAIL_COND(!particles);
+	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);
+	return particles->data.attractor_count;
+}
+
+void RasterizerDummy::particles_set_attractor_pos(RID p_particles, int p_attractor, const Vector3& p_pos) {
+
+	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;;
+}
+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());
+	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 );
+	ERR_FAIL_COND(!particles);
+	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 {
+
+	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) {
+
+	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;
+
+}
+RID RasterizerDummy::particles_get_material(RID p_particles) const {
+
+	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 );
+	ERR_FAIL_COND(!particles);
+	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);
+	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);
+	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 );
+	ERR_FAIL_COND(!particles);
+	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());
+	return particles->data.visibility_aabb;
+}
+
+/* SKELETON API */
+
+RID RasterizerDummy::skeleton_create() {
+
+	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) {
+
+	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 );
+	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) {
+
+	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	ERR_FAIL_COND(!skeleton);
+	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) {
+
+	Skeleton *skeleton = skeleton_owner.get( p_skeleton );
+	ERR_FAIL_COND_V(!skeleton, 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;
+	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);
+	return light->type;
+}
+
+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;
+}
+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() );
+	return light->colors[p_type];
+}
+
+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;
+}
+
+bool RasterizerDummy::light_has_shadow(RID p_light) const {
+
+	Light *light = light_owner.get(p_light);
+	ERR_FAIL_COND_V(!light,false);
+	return light->shadow_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;
+
+}
+bool RasterizerDummy::light_is_volumetric(RID p_light) const {
+
+	Light *light = light_owner.get(p_light);
+	ERR_FAIL_COND_V(!light,false);
+	return light->volumetric_enabled;
+}
+
+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;
+}
+RID RasterizerDummy::light_get_projector(RID p_light) const {
+
+	Light *light = light_owner.get(p_light);
+	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 );
+	ERR_FAIL_COND(!light);
+	ERR_FAIL_INDEX( p_var, VS::LIGHT_PARAM_MAX );
+
+	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);
+
+	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) {
+
+	Light * light = light_owner.get( p_light );
+	ERR_FAIL_COND(!light);
+
+
+};
+
+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) {
+
+
+}
+
+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) {
+
+
+}
+
+VS::LightDirectionalShadowMode RasterizerDummy::light_directional_get_shadow_mode(RID p_light) const {
+
+	return VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL;
+}
+
+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 {
+
+	return 0;
+}
+
+
+AABB RasterizerDummy::light_get_aabb(RID p_light) const {
+
+	Light *light = light_owner.get( p_light );
+	ERR_FAIL_COND_V(!light,AABB());
+
+	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 ) );
+		} break;
+		case VS::LIGHT_OMNI: {
+
+			float r = light->vars[VS::LIGHT_PARAM_RADIUS];
+			return AABB( -Vector3(r,r,r), Vector3(r,r,r)*2 );
+		} break;
+		case VS::LIGHT_DIRECTIONAL: {
+
+			return AABB();
+		} break;
+		default: {}
+	}
+
+	ERR_FAIL_V( AABB() );
+}
+
+
+RID RasterizerDummy::light_instance_create(RID 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;
+
+
+	return light_instance_owner.make_rid( light_instance );
+}
+void RasterizerDummy::light_instance_set_transform(RID p_light_instance,const Transform& p_transform) {
+
+	LightInstance *lighti = light_instance_owner.get( p_light_instance );
+	ERR_FAIL_COND(!lighti);
+	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);
+
+	switch(lighti->base->type) {
+
+		case VS::LIGHT_DIRECTIONAL: return SHADOW_PSM; break;
+		case VS::LIGHT_OMNI: return SHADOW_DUAL_PARABOLOID; break;
+		case VS::LIGHT_SPOT: return SHADOW_SIMPLE; break;
+	}
+
+	return Rasterizer::SHADOW_NONE;
+}
+
+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) {
+
+
+}
+
+int RasterizerDummy::light_instance_get_shadow_passes(RID p_light_instance) const {
+
+	return 0;
+}
+
+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 );
+	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;
+
+}
+void RasterizerDummy::shadow_clear_near() {
+
+
+}
+
+bool RasterizerDummy::shadow_allocate_near(RID p_light) {
+
+	return false;
+}
+
+bool RasterizerDummy::shadow_allocate_far(RID p_light) {
+
+	return false;
+}
+
+/* PARTICLES INSTANCE */
+
+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;
+	return particles_instance_owner.make_rid(particles_instance);
+}
+
+void RasterizerDummy::particles_instance_set_transform(RID p_particles_instance,const Transform& p_transform) {
+
+	ParticlesInstance *particles_instance=particles_instance_owner.get(p_particles_instance);
+	ERR_FAIL_COND(!particles_instance);
+	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(){
+
+	return RID();
+
+}
+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{
+
+	return RID();
+
+}
+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::clear_viewport(const Color& p_color) {
+
+
+};
+
+void RasterizerDummy::set_viewport(const VS::ViewportRect& p_viewport) {
+
+
+
+}
+
+void RasterizerDummy::set_render_target(RID p_render_target) {
+
+
+}
+
+
+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::set_camera(const Transform& p_world,const CameraMatrix& p_projection) {
+
+
+}
+
+void RasterizerDummy::add_light( RID p_light_instance ) {
+
+
+
+}
+
+
+
+
+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_particles( const RID& p_particle_instance, const InstanceData *p_data){
+
+
+
+}
+
+
+
+void RasterizerDummy::end_scene() {
+
+
+}
+void RasterizerDummy::end_shadow_map() {
+
+}
+
+
+void RasterizerDummy::end_frame() {
+
+
+}
+
+/* CANVAS API */
+
+
+void RasterizerDummy::canvas_begin() {
+
+
+
+}
+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_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_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, 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_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) {
+
+
+}
+
+/* ENVIRONMENT */
+
+RID RasterizerDummy::environment_create() {
+
+	Environment * env = memnew( Environment );
+	return environment_owner.make_rid(env);
+}
+
+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_COND(!env);
+	env->bg_mode=p_bg;
+}
+
+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);
+	return env->bg_mode;
+}
+
+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_COND(!env);
+	env->bg_param[p_param]=p_value;
+
+}
+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());
+	return env->bg_param[p_param];
+
+}
+
+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_COND(!env);
+	env->fx_enabled[p_effect]=p_enabled;
+}
+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);
+	return env->fx_enabled[p_effect];
+
+}
+
+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_COND(!env);
+	env->fx_param[p_param]=p_value;
+}
+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());
+	return env->fx_param[p_param];
+
+}
+
+/*MISC*/
+
+bool RasterizerDummy::is_texture(const RID& p_rid) const {
+
+	return texture_owner.owns(p_rid);
+}
+bool RasterizerDummy::is_material(const RID& p_rid) const {
+
+	return material_owner.owns(p_rid);
+}
+bool RasterizerDummy::is_mesh(const RID& p_rid) const {
+
+	return mesh_owner.owns(p_rid);
+}
+bool RasterizerDummy::is_multimesh(const RID& p_rid) const {
+
+	return multimesh_owner.owns(p_rid);
+}
+bool RasterizerDummy::is_particles(const RID &p_beam) const {
+
+	return particles_owner.owns(p_beam);
+}
+
+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 {
+
+	return light_instance_owner.owns(p_rid);
+}
+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 {
+
+	return skeleton_owner.owns(p_rid);
+}
+bool RasterizerDummy::is_environment(const RID& p_rid) const {
+
+	return environment_owner.owns(p_rid);
+}
+
+bool RasterizerDummy::is_shader(const RID& p_rid) const {
+
+	return false;
+}
+
+void RasterizerDummy::free(const RID& p_rid) {
+
+	if (texture_owner.owns(p_rid)) {
+
+		// delete the texture
+		Texture *texture = texture_owner.get(p_rid);
+		texture_owner.free(p_rid);
+		memdelete(texture);
+
+	} else if (shader_owner.owns(p_rid)) {
+
+		// delete the texture
+		Shader *shader = shader_owner.get(p_rid);
+		shader_owner.free(p_rid);
+		memdelete(shader);
+
+	} else if (material_owner.owns(p_rid)) {
+
+		Material *material = material_owner.get( p_rid );
+		material_owner.free(p_rid);
+		memdelete(material);
+
+	} else if (mesh_owner.owns(p_rid)) {
+
+		Mesh *mesh = mesh_owner.get(p_rid);
+
+		for (int i=0;i<mesh->surfaces.size();i++) {
+
+			memdelete( mesh->surfaces[i] );
+		};
+
+		mesh->surfaces.clear();
+		mesh_owner.free(p_rid);
+		memdelete(mesh);
+
+	} else if (multimesh_owner.owns(p_rid)) {
+
+	       MultiMesh *multimesh = multimesh_owner.get(p_rid);
+	       multimesh_owner.free(p_rid);
+	       memdelete(multimesh);
+
+	} else if (particles_owner.owns(p_rid)) {
+
+		Particles *particles = particles_owner.get(p_rid);
+		particles_owner.free(p_rid);
+		memdelete(particles);
+	} else if (particles_instance_owner.owns(p_rid)) {
+
+		ParticlesInstance *particles_isntance = particles_instance_owner.get(p_rid);
+		particles_instance_owner.free(p_rid);
+		memdelete(particles_isntance);
+
+	} else if (skeleton_owner.owns(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_owner.free(p_rid);
+		memdelete(light);
+
+	} else if (light_instance_owner.owns(p_rid)) {
+
+		LightInstance *light_instance = light_instance_owner.get( p_rid );
+		light_instance_owner.free(p_rid);
+		memdelete( light_instance );
+
+
+	} else if (environment_owner.owns(p_rid)) {
+
+		Environment *env = environment_owner.get( p_rid );
+		environment_owner.free(p_rid);
+		memdelete( env );
+	};
+}
+
+
+void RasterizerDummy::custom_shade_model_set_shader(int p_model, RID p_shader) {
+
+
+};
+
+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) {
+
+};
+
+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_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) {
+
+	return 0;
+}
+
+bool RasterizerDummy::needs_to_draw_next_frame() const {
+
+	return false;
+}
+
+
+bool RasterizerDummy::has_feature(VS::Features p_feature) const {
+
+	return false;
+
+}
+
+
+RasterizerDummy::RasterizerDummy() {
+
+};
+
+RasterizerDummy::~RasterizerDummy() {
+
+};
+
diff --git a/servers/visual/rasterizer_dummy.h b/servers/visual/rasterizer_dummy.h
new file mode 100644
index 0000000000..7ae03a1c0b
--- /dev/null
+++ b/servers/visual/rasterizer_dummy.h
@@ -0,0 +1,725 @@
+/*************************************************************************/
+/*  rasterizer_dummy.h                                                   */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef RASTERIZER_DUMMY_H
+#define RASTERIZER_DUMMY_H
+
+#include "servers/visual/rasterizer.h"
+
+
+#include "image.h"
+#include "rid.h"
+#include "servers/visual_server.h"
+#include "list.h"
+#include "map.h"
+#include "camera_matrix.h"
+#include "sort.h"
+
+
+#include "servers/visual/particle_system_sw.h"
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+class RasterizerDummy : public Rasterizer {
+
+	struct Texture {
+
+		uint32_t flags;
+		int width,height;
+		Image::Format format;
+		Image image[6];
+		Texture() {
+
+			flags=width=height=0;
+			format=Image::FORMAT_GRAYSCALE;
+		}
+
+		~Texture() {
+
+		}
+	};
+
+	mutable RID_Owner<Texture> texture_owner;
+
+	struct Shader {
+
+		String vertex_code;
+		String fragment_code;
+		VS::ShaderMode mode;
+		Map<StringName,Variant> params;
+		int fragment_line;
+		int vertex_line;
+		bool valid;
+		bool has_alpha;
+		bool use_world_transform;
+
+	};
+
+	mutable RID_Owner<Shader> shader_owner;
+
+
+	struct Material {
+
+		bool flags[VS::MATERIAL_FLAG_MAX];
+		bool hints[VS::MATERIAL_HINT_MAX];
+
+		VS::MaterialShadeModel shade_model;
+
+		VS::MaterialBlendMode blend_mode;
+
+		float line_width;
+		float point_size;
+
+		RID shader; // shader material
+
+		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_HINT_MAX;i++)
+				hints[i]=false;
+
+			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 {
+			GEOMETRY_INVALID,
+			GEOMETRY_SURFACE,
+			GEOMETRY_POLY,
+			GEOMETRY_PARTICLES,
+			GEOMETRY_MULTISURFACE,
+		};
+
+		Type type;
+		RID material;
+		bool has_alpha;
+		bool material_owned;
+
+		Geometry() { has_alpha=false; material_owned = false; }
+		virtual ~Geometry() {};
+	};
+
+	struct GeometryOwner {
+
+		virtual ~GeometryOwner() {}
+	};
+
+	class Mesh;
+
+	struct Surface : public Geometry {
+
+		Array data;
+		Array morph_data;
+
+		bool packed;
+		bool alpha_sort;
+		int morph_target_count;
+		AABB aabb;
+
+		VS::PrimitiveType primitive;
+
+		uint32_t format;
+		uint32_t morph_format;
+
+		RID material;
+		bool material_owned;
+
+
+		Surface() {
+
+			packed=false;
+			morph_target_count=0;
+			material_owned=false;
+			format=0;
+			morph_format=0;
+
+			primitive=VS::PRIMITIVE_POINTS;
+		}
+
+		~Surface() {
+
+		}
+	};
+
+
+	struct Mesh {
+
+		bool active;
+		Vector<Surface*> surfaces;
+		int morph_target_count;
+		VS::MorphTargetMode morph_target_mode;
+
+		mutable uint64_t last_pass;
+		Mesh() {
+			morph_target_mode=VS::MORPH_MODE_NORMALIZED;
+			morph_target_count=0;
+			last_pass=0;
+			active=false;
+		}
+	};
+	mutable RID_Owner<Mesh> mesh_owner;
+
+	struct MultiMesh;
+
+	struct MultiMeshSurface : public Geometry {
+
+		Surface *surface;
+		MultiMeshSurface() { type=GEOMETRY_MULTISURFACE; }
+	};
+
+	struct MultiMesh : public GeometryOwner {
+
+		struct Element {
+
+			Transform xform;
+			Color color;
+		};
+
+		AABB aabb;
+		RID mesh;
+		int visible;
+
+		//IDirect3DVertexBuffer9* instance_buffer;
+		Vector<Element> elements;
+
+		MultiMesh() {
+			visible=-1;
+		}
+
+
+	};
+
+	mutable RID_Owner<MultiMesh> multimesh_owner;
+
+	struct Particles : public Geometry {
+
+		ParticleSystemSW data; // software particle system
+
+		Particles() {
+			type=GEOMETRY_PARTICLES;
+
+		}
+	};
+
+	mutable RID_Owner<Particles> particles_owner;
+
+	struct ParticlesInstance : public GeometryOwner {
+
+		RID particles;
+
+		ParticleSystemProcessSW particles_process;
+		Transform transform;
+
+		ParticlesInstance() {  }
+	};
+
+	mutable RID_Owner<ParticlesInstance> particles_instance_owner;
+	ParticleSystemDrawInfoSW particle_draw_info;
+
+	struct Skeleton {
+
+		Vector<Transform> bones;
+
+	};
+
+	mutable RID_Owner<Skeleton> skeleton_owner;
+
+
+	struct Light {
+
+		VS::LightType type;
+		float vars[VS::LIGHT_PARAM_MAX];
+		Color colors[3];
+		bool shadow_enabled;
+		RID projector;
+		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;
+			colors[VS::LIGHT_COLOR_AMBIENT]=Color(0,0,0);
+			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];
+		Variant fx_param[VS::ENV_FX_PARAM_MAX];
+
+		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_SCALAR]=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;
+			fx_param[VS::ENV_FX_PARAM_GAMMA]=1.0;
+
+		}
+
+	};
+
+	mutable RID_Owner<Environment> environment_owner;
+
+	struct ShadowBuffer;
+
+	struct LightInstance {
+
+		struct SplitInfo {
+
+			CameraMatrix camera;
+			Transform transform;
+			float near;
+			float far;
+		};
+
+		RID light;
+		Light *base;
+		Transform transform;
+		CameraMatrix projection;
+
+		Transform custom_transform;
+		CameraMatrix custom_projection;
+
+		Vector3 light_vector;
+		Vector3 spot_vector;
+		float linear_att;
+
+
+		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 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;
+
+	/* SHADER API */
+
+	virtual RID shader_create(VS::ShaderMode p_mode=VS::SHADER_MATERIAL);
+
+	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,int p_vertex_ofs=0,int p_fragment_ofs=0);
+	virtual String shader_get_fragment_code(RID p_shader) const;
+	virtual String shader_get_vertex_code(RID p_shader) const;
+
+	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
+
+	/* COMMON MATERIAL API */
+
+	virtual RID material_create();
+
+	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_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_hint(RID p_material, VS::MaterialHint p_hint,bool p_enabled);
+	virtual bool material_get_hint(RID p_material,VS::MaterialHint p_hint) const;
+
+	virtual void material_set_shade_model(RID p_material, VS::MaterialShadeModel p_model);
+	virtual VS::MaterialShadeModel material_get_shade_model(RID p_material) const;
+
+	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 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_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 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 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;
+	virtual int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const;
+	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 int mesh_get_surface_count(RID p_mesh) const;
+
+	virtual AABB mesh_get_aabb(RID p_mesh) const;
+
+	/* MULTIMESH API */
+
+	virtual RID multimesh_create();
+
+	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 RID multimesh_get_mesh(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 void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
+
+	/* PARTICLES API */
+
+	virtual RID particles_create();
+
+	virtual void particles_set_amount(RID p_particles, int p_amount);
+	virtual int particles_get_amount(RID p_particles) const;
+
+	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 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 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 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 DVector<Vector3> particles_get_emission_points(RID p_particles) const;
+
+	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 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 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);
+	virtual float particles_get_color_phase_pos(RID p_particles, int p_phase) const;
+
+	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 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_strength(RID p_particles, int p_attractor, float p_force);
+	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 RID particles_get_material(RID p_particles) const;
+
+	virtual AABB particles_get_aabb(RID p_particles) const;
+
+	virtual void particles_set_height_from_velocity(RID p_particles, bool p_enable);
+	virtual bool particles_has_height_from_velocity(RID p_particles) const;
+
+	virtual void particles_set_use_local_coordinates(RID p_particles, bool p_enable);
+	virtual bool particles_is_using_local_coordinates(RID p_particles) const;
+
+	/* SKELETON API */
+
+	virtual RID skeleton_create();
+	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);
+
+
+	/* 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_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 bool light_is_volumetric(RID p_light) const;
+
+	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 VS::LightOp light_get_operator(RID p_light) const;
+
+	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 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 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 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 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 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);
+
+	/* VIEWPORT */
+
+	virtual RID viewport_data_create();
+
+	virtual RID render_target_create();
+	virtual void render_target_set_size(RID p_render_target, int p_width, int p_height);
+	virtual RID render_target_get_texture(RID p_render_target) const;
+	virtual bool render_target_renedered_in_frame(RID p_render_target);
+
+	/* RENDER API */
+	/* all calls (inside begin/end shadow) are always warranted to be in the following order: */
+
+	virtual void begin_frame();
+
+	virtual void set_viewport(const VS::ViewportRect& p_viewport);
+	virtual void set_render_target(RID p_render_target);
+	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_camera(const Transform& p_world,const CameraMatrix& p_projection);
+
+	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_particles( const RID& p_particle_instance, const InstanceData *p_data);
+
+	virtual void end_scene();
+	virtual void end_shadow_map();
+
+	virtual void end_frame();
+
+	/* CANVAS API */
+
+	virtual void canvas_begin();
+	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_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, 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);
+
+	/* ENVIRONMENT */
+
+	virtual RID environment_create();
+
+	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_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;
+
+
+	/*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_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_shader(const RID& p_rid) const;
+
+	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 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 init();
+	virtual void finish();
+
+	virtual int get_render_info(VS::RenderInfo p_info);
+
+	virtual bool needs_to_draw_next_frame() const;
+
+	virtual bool has_feature(VS::Features p_feature) const;
+
+
+	RasterizerDummy();
+	virtual ~RasterizerDummy();
+};
+
+
+#endif // RASTERIZER_DUMMY_H
diff --git a/servers/visual/shader_compiler.cpp b/servers/visual/shader_compiler.cpp
new file mode 100644
index 0000000000..df2ffa6889
--- /dev/null
+++ b/servers/visual/shader_compiler.cpp
@@ -0,0 +1,30 @@
+/*************************************************************************/
+/*  shader_compiler.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "shader_compiler.h"
+
diff --git a/servers/visual/shader_compiler.h b/servers/visual/shader_compiler.h
new file mode 100644
index 0000000000..6bb523fbce
--- /dev/null
+++ b/servers/visual/shader_compiler.h
@@ -0,0 +1,142 @@
+/*************************************************************************/
+/*  shader_compiler.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef SHADER_COMPILER_H
+#define SHADER_COMPILER_H
+
+#include "map.h"
+#include "list.h"
+#include "vector.h"
+#if 0
+class ShaderSyntax {
+public:
+
+
+	enum DataType {
+		TYPE_BOOL,
+		TYPE_FLOAT,
+		TYPE_VEC3,
+		TYPE_TRANSFORM,
+		TYPE_TEXTURE
+	};
+
+	enum Operator {
+		OP_ASSIGN,
+		OP_ADD,
+		OP_SUB,
+		OP_MUL,
+		OP_DIV,
+		OP_NEG,
+		OP_CMP_EQ,
+		OP_CMP_NEQ,
+		OP_CMP_LEQ,
+		OP_CMP_GEQ,
+		OP_CMP_OR,
+		OP_CMP_AND,
+		OP_CALL
+	};
+
+	struct Node {
+
+		enum Type {
+			TYPE_PROGRAM,
+			TYPE_FUNCTION,
+			TYPE_BLOCK,
+			TYPE_VARIABLE,
+			TYPE_OPERATOR,
+			TYPE_IF,
+		};
+
+		Node * parent;
+		Type type;
+
+		virtual ~Node() {}
+	};
+
+
+	struct OperatorNode : public Node {
+
+		Operator op;
+		Vector<Node*> arguments;
+		OperatorNode() { type=TYPE_OPERATOR; }
+	};
+
+	struct VariableNode : public Node {
+
+		StringName variable;
+		VariableNode() { type=TYPE_VARIABLE; }
+	};
+
+	struct BlockNode : public Node {
+
+		Map<StringName,DataType> variables;
+		List<Node*> subnodes;
+		BlockNode() { type=TYPE_BLOCK; }
+	};
+
+	struct ConditionalNode : public Node {
+
+		Node *test;
+		Node *do_if;
+		Node *do_else;
+		ConditionalNode() { type=TYPE_CONDITIONAL; }
+	};
+
+
+	struct FunctionNode : public Node {
+
+		struct Argument {
+
+			StringName name;
+			DataType type;
+		};
+
+		Vector<Argument> arguments;
+		Node *body;
+
+		FunctionNode() { type=TYPE_FUNCTION; }
+
+	};
+
+
+	struct ProgramNode : public Node {
+
+		Vector<FunctionNode*> functions;
+		Node *body;
+
+		ProgramNode() { type=TYPE_PROGRAM; }
+	};
+
+
+
+
+	ShaderCompiler();
+};
+
+#endif // SHADER_COMPILER_H
+#endif
diff --git a/servers/visual/shader_graph.cpp b/servers/visual/shader_graph.cpp
new file mode 100644
index 0000000000..8fb7196276
--- /dev/null
+++ b/servers/visual/shader_graph.cpp
@@ -0,0 +1,455 @@
+/*************************************************************************/
+/*  shader_graph.cpp                                                     */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "shader_graph.h"
+
+#if 0
+
+
+struct _ConnectionKey {
+
+	int node;
+	int slot;	
+		
+	_FORCE_INLINE_ _ConnectionKey(int p_node=0,int p_slot=0) { node=p_node; slot=p_slot; }
+	
+	_FORCE_INLINE_ bool operator<(const _ConnectionKey& p_other) const {
+	
+		if (node<p_other.node)
+			return true;
+		else if (node>p_other.node)
+			return false;			
+		else
+			return slot<p_other.slot;
+	}
+};
+
+Error ShaderGraph::generate(ShaderCodeGenerator * p_generator) const {
+	
+	Map<int,Node>::Element *E = node_map.front();
+	int i=0;	
+	while(E) {
+	
+		E->get().order=i++;
+		E->get().out_valid=false;
+		E->get().in_valid=false;
+		E=E->next();
+	}	
+
+	int worst_case=connections.size() * connections.size(); // worst bubble case
+	int iterations=0;
+	int swaps;
+	
+	do {	
+		swaps=0;
+		const List<Connection>::Element *E=connections.front();
+
+		while(E) {
+
+			const Connection &c = E->get();
+			
+			const Node *src = &node_map[c.src_id];
+			const Node *dst = &node_map[c.dst_id];
+						
+			if (src->order > dst->order) {
+			
+				SWAP(src->order, dst->order);
+				swaps++;
+			}
+			
+			E=E->next();
+		}
+		
+	
+		iterations++;
+		
+	} while (iterations<=worst_case && swaps>0);
+	
+	ERR_FAIL_COND_V( swaps != 0 , ERR_CYCLIC_LINK );
+	
+	//node array
+	Vector<const Node*> nodes;
+	nodes.resize(node_map.size());
+	
+	E = node_map.front();
+	while(E) {
+	
+		ERR_FAIL_INDEX_V( E->get().order, nodes.size(), ERR_BUG);
+		nodes[E->get().order]=&E->get();
+		E=E->next();
+	}
+	
+	//connection set
+	
+	Map<_ConnectionKey,int> in_connection_map;
+	Map<_ConnectionKey,List<int> > out_connection_map;
+	Map<_ConnectionKey,int> in_node_map;
+	Map<_ConnectionKey,List<int> > out_node_map;
+
+	const List<Connection>::Element *CE=connections.front();
+	i=0;
+	while(CE) {
+		const Connection &c = CE->get();
+		
+		_ConnectionKey in_k;
+		in_k.node=node_map[c.dst_id].order;
+		in_k.slot=c.dst_slot;
+		in_connection_map[in_k]=i;
+		in_node_map[in_k]=node_map[c.src_id].order;
+
+		_ConnectionKey out_k;
+		out_k.node=node_map[c.src_id].order;
+		out_k.slot=c.src_slot;
+		if (!out_connection_map.has(out_k))
+			out_connection_map[out_k]=List<int>();
+		out_connection_map[out_k].push_back(i);
+		if(!out_node_map.has(out_k))
+			out_node_map[out_k]=List<int>();
+		out_node_map[out_k].push_back(node_map[c.dst_id].order);
+		
+		i++;
+		CE=CE->next();
+	}
+	
+	// validate nodes if they are connected to an output
+
+	for(int i=nodes.size()-1;i>=0;i--) {
+
+		if (VisualServer::shader_get_output_count(nodes[i]->type)==0) {
+			// an actual graph output
+
+			_ConnectionKey in_k;
+			in_k.node=nodes[i]->order;
+			in_k.slot=0;
+
+			if (in_node_map.has(in_k)) {
+				nodes[i]->out_valid=true;
+			}
+		} else {
+			// regular node
+
+			bool valid=false;
+			for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
+
+				_ConnectionKey key(nodes[i]->order,j);
+
+				if (out_node_map.has(key)) {
+					for(List<int>::Element *CE=out_node_map[key].front();CE;CE=CE->next()) {
+
+						int to_node=CE->get();
+						ERR_CONTINUE(to_node<0 || to_node >=nodes.size());
+						if (nodes[to_node]->out_valid) {
+							valid=true;
+							break;
+						}
+
+
+					}
+				}
+				if (valid)
+					break;
+
+			}
+
+			nodes[i]->out_valid=valid;
+		}
+	}
+
+	// validate nodes if they are connected to an input
+
+	for(int i=0;i<nodes.size();i++) {
+
+		if (VisualServer::shader_get_input_count(nodes[i]->type)==0) {
+			// an actual graph input
+
+			int out_count=VisualServer::shader_get_output_count(nodes[i]->type);
+
+
+			for(int j=0;j<out_count;j++) {
+
+				_ConnectionKey out_k;
+				out_k.node=nodes[i]->order;
+				out_k.slot=j;
+				if (out_node_map.has(out_k)) {
+					nodes[i]->in_valid=true;
+					break;
+				}
+			}
+
+		} else {
+			// regular node
+			// this is very important.. for a node to be valid, all its inputs need to be valid
+			bool valid=true;
+			for(int j=0;j<VS::shader_get_input_count(nodes[i]->type);j++) {
+
+
+				bool in_valid=false;
+				_ConnectionKey key(nodes[i]->order,j);
+				if (in_node_map.has(key)) {
+
+					int from_node=in_node_map[key];
+					ERR_CONTINUE(from_node<0 || from_node>=nodes.size());
+					if (nodes[from_node]->in_valid)
+						in_valid=true;
+
+				}
+
+				if (!in_valid) {
+					valid=false;
+					break;
+				}
+
+			}
+
+			nodes[i]->in_valid=valid;
+		}
+	}
+
+	// write code
+		
+	p_generator->begin();
+		
+	for(int i=0;i<nodes.size();i++) {
+
+
+		if (!nodes[i]->out_valid || !nodes[i]->in_valid) // valid in both ways
+			continue; // skip node
+
+		Vector<int> in_indices;
+		in_indices.resize(VS::shader_get_input_count(nodes[i]->type));
+		Vector<int> out_indices;
+		Vector<int> out_slot_indices;
+		
+		for(int j=0;j<in_indices.size();j++) {
+		
+			_ConnectionKey key(nodes[i]->order,j);
+			if (in_connection_map.has(key))
+				in_indices[j]=in_connection_map[key];
+			else
+				in_indices[j]=-1;			
+		}
+		
+		for(int j=0;j<VS::shader_get_output_count(nodes[i]->type);j++) {
+		
+			_ConnectionKey key(nodes[i]->order,j);
+			if (out_connection_map.has(key)) {
+				for(List<int>::Element *CE=out_connection_map[key].front();CE;CE=CE->next()) {
+				
+					out_indices.push_back(CE->get());
+					out_slot_indices.push_back(j);
+				}
+			}
+		}
+		
+		Error err = p_generator->add_node(nodes[i]->type,i,nodes[i]->id,nodes[i]->param,in_indices,out_indices,out_slot_indices);
+		ERR_FAIL_COND_V( err, err );
+	}
+		
+	p_generator->end();
+		
+	
+	return OK;
+}
+
+void ShaderGraph::node_add(VS::ShaderNodeType p_type,int p_id) {
+
+
+	ERR_FAIL_COND( node_map.has(p_id ) );
+	ERR_FAIL_INDEX( p_type, VS::NODE_TYPE_MAX );
+	Node node;
+	
+	node.type=p_type;
+	node.id=p_id;
+	node.x=0;
+	node.y=0;
+
+	node_map[p_id]=node;
+
+}
+
+void ShaderGraph::node_set_pos(int p_id, int p_x,int p_y) {
+
+	ERR_FAIL_COND(!node_map.has(p_id));
+	node_map[p_id].x=p_x;
+	node_map[p_id].y=p_y;
+}
+int ShaderGraph::node_get_pos_x(int p_id) const {
+
+	ERR_FAIL_COND_V(!node_map.has(p_id),-1);
+	return node_map[p_id].x;
+}
+int ShaderGraph::node_get_pos_y(int p_id) const {
+
+	ERR_FAIL_COND_V(!node_map.has(p_id),-1);
+	return node_map[p_id].y;
+}
+
+void ShaderGraph::node_remove(int p_id) {
+
+	ERR_FAIL_COND(!node_map.has(p_id));
+	
+	//erase connections associated with node
+	List<Connection>::Element *N,*E=connections.front();
+	while(E) {
+		N=E->next();
+		const Connection &c = E->get();
+		if (c.src_id==p_id || c.dst_id==p_id) {
+		
+			connections.erase(E);
+		}
+		E=N;
+	}
+
+	node_map.erase(p_id);
+}
+
+void ShaderGraph::node_change_type(int p_id, VS::ShaderNodeType p_type) {
+
+	ERR_FAIL_COND(!node_map.has(p_id));
+	node_map[p_id].type=p_type;
+	node_map[p_id].param=Variant();
+
+}
+
+void ShaderGraph::node_set_param(int p_id, const Variant& p_value) {
+	
+	ERR_FAIL_COND(!node_map.has(p_id));
+	node_map[p_id].param=p_value;	
+}
+
+void ShaderGraph::get_node_list(List<int> *p_node_list) const {
+
+	Map<int,Node>::Element *E = node_map.front();
+	
+	while(E) {
+	
+		p_node_list->push_back(E->key());
+		E=E->next();
+	}
+}
+
+
+VS::ShaderNodeType ShaderGraph::node_get_type(int p_id) const {
+
+	ERR_FAIL_COND_V(!node_map.has(p_id),VS::NODE_TYPE_MAX);
+	return node_map[p_id].type;
+}
+
+Variant ShaderGraph::node_get_param(int p_id) const {
+
+	ERR_FAIL_COND_V(!node_map.has(p_id),Variant());
+	return node_map[p_id].param;	
+}
+
+
+Error ShaderGraph::connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
+
+	ERR_FAIL_COND_V(p_src_id==p_dst_id, ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(!node_map.has(p_src_id), ERR_INVALID_PARAMETER);
+	ERR_FAIL_COND_V(!node_map.has(p_dst_id), ERR_INVALID_PARAMETER);
+	VisualServer::ShaderNodeType type_src=node_map[p_src_id].type;
+	VisualServer::ShaderNodeType type_dst=node_map[p_dst_id].type;
+	ERR_FAIL_INDEX_V( p_src_slot, VisualServer::shader_get_output_count(type_src), ERR_INVALID_PARAMETER );
+	ERR_FAIL_INDEX_V( p_dst_slot, VisualServer::shader_get_input_count(type_dst), ERR_INVALID_PARAMETER );
+	ERR_FAIL_COND_V(VisualServer::shader_is_output_vector(type_src,p_src_slot) != VisualServer::shader_is_input_vector(type_dst,p_dst_slot), ERR_INVALID_PARAMETER );
+
+
+	List<Connection>::Element *E=connections.front();
+	while(E) {
+		const Connection &c = E->get();
+		ERR_FAIL_COND_V(c.dst_slot==p_dst_slot && c.dst_id == p_dst_id, ERR_ALREADY_EXISTS);
+		
+		E=E->next();
+	}
+	
+	Connection c;
+	c.src_slot=p_src_slot;
+	c.src_id=p_src_id;
+	c.dst_slot=p_dst_slot;
+	c.dst_id=p_dst_id;
+		
+	connections.push_back(c);
+
+	return OK;
+}
+
+bool ShaderGraph::is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const {
+
+	const List<Connection>::Element *E=connections.front();
+	while(E) {
+		const Connection &c = E->get();
+		if (c.dst_slot==p_dst_slot && c.dst_id == p_dst_id && c.src_slot==p_src_slot && c.src_id == p_src_id)
+			return true;
+
+		E=E->next();
+	}
+
+	return false;
+}
+
+void ShaderGraph::disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) {
+
+	List<Connection>::Element *N,*E=connections.front();
+	while(E) {
+		N=E->next();
+		const Connection &c = E->get();
+		if (c.src_slot==p_src_slot && c.src_id==p_src_id && c.dst_slot==p_dst_slot && c.dst_id == p_dst_id) {
+		
+			connections.erase(E);
+		}
+		E=N;
+	}
+	
+
+}
+
+
+void ShaderGraph::clear() {
+
+	connections.clear();
+	node_map.clear();
+}
+
+List<ShaderGraph::Connection> ShaderGraph::get_connection_list() const {
+
+	return connections;
+
+}
+
+ShaderGraph::ShaderGraph() {
+
+
+}
+
+
+ShaderGraph::~ShaderGraph() {
+
+}
+
+
+#endif
diff --git a/servers/visual/shader_graph.h b/servers/visual/shader_graph.h
new file mode 100644
index 0000000000..5c5079202f
--- /dev/null
+++ b/servers/visual/shader_graph.h
@@ -0,0 +1,112 @@
+/*************************************************************************/
+/*  shader_graph.h                                                       */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef SHADER_GRAPH_H
+#define SHADER_GRAPH_H
+
+#if 0
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+
+#include "servers/visual_server.h"
+#include "map.h"
+
+
+class ShaderCodeGenerator {
+public:
+
+	virtual void begin()=0;
+	virtual Error add_node(VS::ShaderNodeType p_type,int p_node_pos,int p_id,const Variant& p_param,const Vector<int>& p_in_connections,const Vector<int>& p_out_connections,const Vector<int>& p_out_connection_outputs)=0;
+	virtual void end()=0;
+	
+	virtual ~ShaderCodeGenerator() {}
+};
+
+class ShaderGraph {
+public:
+
+
+	struct Connection {
+
+		int src_id;
+		int src_slot;
+		int dst_id;
+		int dst_slot;
+	};
+
+private:
+	struct Node {
+	
+		int16_t x,y;
+		VS::ShaderNodeType type;
+		Variant param;
+		int id;
+		mutable int order; // used for sorting
+		mutable bool out_valid;
+		mutable bool in_valid;
+	};
+
+	Map<int,Node> node_map;
+
+	List<Connection> connections;
+	
+public:
+
+	Error generate(ShaderCodeGenerator * p_generator) const;
+
+	void node_add(VS::ShaderNodeType p_type,int p_id);
+	void node_remove(int p_id);
+	void node_change_type(int p_id, VS::ShaderNodeType p_type);
+	void node_set_param(int p_id, const Variant& p_value);
+
+	void node_set_pos(int p_id, int p_x,int p_y);
+	int node_get_pos_x(int p_id) const;
+	int node_get_pos_y(int p_id) const;
+	
+	void get_node_list(List<int> *p_node_list) const;
+	void get_sorted_node_list(List<int> *p_node_list) const;
+	VS::ShaderNodeType node_get_type(int p_id) const;
+	Variant node_get_param(int p_id) const;
+
+	Error connect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);
+	bool is_connected(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot) const;
+	void disconnect(int p_src_id,int p_src_slot, int p_dst_id,int p_dst_slot);	
+
+	void clear();
+
+	List<Connection> get_connection_list() const;
+
+
+	ShaderGraph();	
+	~ShaderGraph();
+
+};
+#endif
+#endif
diff --git a/servers/visual/shader_language.cpp b/servers/visual/shader_language.cpp
new file mode 100644
index 0000000000..3061c2ddff
--- /dev/null
+++ b/servers/visual/shader_language.cpp
@@ -0,0 +1,2385 @@
+/*************************************************************************/
+/*  shader_language.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "shader_language.h"
+#include "print_string.h"
+#include "os/os.h"
+static bool _is_text_char(CharType 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');
+}
+
+static bool _is_hex(CharType c) {
+
+	return (c>='0' && c<='9') || (c>='a' && c<='f') || (c>='A' && c<='F');
+}
+
+const char * ShaderLanguage::token_names[TK_MAX]={
+	"EMPTY",
+	"INDENTIFIER",
+	"TRUE",
+	"FALSE",
+	"REAL_CONSTANT",
+	"TYPE_VOID",
+	"TYPE_BOOL",
+	"TYPE_FLOAT",
+	"TYPE_VEC2",
+	"TYPE_VEC3",
+	"TYPE_VEC4",
+	"TYPE_MAT3",
+	"TYPE_MAT4",
+	"TYPE_TEXTURE",
+	"TYPE_CUBEMAP",
+	"TYPE_COLOR",
+	"OP_EQUAL",
+	"OP_NOT_EQUAL",
+	"OP_LESS",
+	"OP_LESS_EQUAL",
+	"OP_GREATER",
+	"OP_GREATER_EQUAL",
+	"OP_AND",
+	"OP_OR",
+	"OP_NOT",
+	"OP_ADD",
+	"OP_SUB",
+	"OP_MUL",
+	"OP_DIV",
+	"OP_NEG",
+	"OP_ASSIGN",
+	"OP_ASSIGN_ADD",
+	"OP_ASSIGN_SUB",
+	"OP_ASSIGN_MUL",
+	"OP_ASSIGN_DIV",
+	"CF_IF",
+	"CF_ELSE",
+	"CF_RETURN",
+	"BRACKET_OPEN",
+	"BRACKET_CLOSE",
+	"CURLY_BRACKET_OPEN",
+	"CURLY_BRACKET_CLOSE",
+	"PARENTHESIS_OPEN",
+	"PARENTHESIS_CLOSE",
+	"COMMA",
+	"SEMICOLON",
+	"PERIOD",
+	"UNIFORM",
+	"ERROR",
+};
+
+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))
+
+	r_chars=1; //by default everything eats one char
+	switch(GETCHAR(0)) {
+
+		case '\t':
+		case '\r':
+		case ' ':
+			return Token();
+		case '\n':
+			r_line++;
+			return Token();
+		case '/': {
+
+			switch(GETCHAR(1)) {
+				case '*': { // block comment
+
+
+					while(true) {
+						if (GETCHAR(r_chars+1)=='0')
+							break;
+						if (GETCHAR(r_chars+1)=='*' && GETCHAR(r_chars+2)=='/')
+							break;
+						if (GETCHAR(r_chars+1)=='\n')
+							r_line++;
+							r_chars++;
+					}
+
+					return Token();
+
+				} break;
+				case '/': { // line comment skip
+
+					while(GETCHAR(r_chars+1)!='\n' && GETCHAR(r_chars+1)!=0) {
+							r_chars++;
+					}
+
+					return Token();
+
+				} break;
+				case '=': { // diveq
+
+					r_chars=2;
+					return Token(TK_OP_ASSIGN_DIV);
+
+				} break;
+				default:
+					return Token(TK_OP_DIV);
+
+			}
+		} break;
+		case '=': {
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_EQUAL);
+			}
+
+			return Token(TK_OP_ASSIGN);
+
+		} break;
+		case '<': {
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_LESS_EQUAL);
+			} /*else if (GETCHAR(1)=='<') {
+				r_chars++;
+				if (GETCHAR(2)=='=') {
+					r_chars++;
+					return Token(TK_OP_ASSIGN_SHIFT_LEFT);
+				}
+
+				return Token(TK_OP_SHIFT_LEFT);
+			}*/
+
+			return Token(TK_OP_LESS);
+
+		} break;
+		case '>': {
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_GREATER_EQUAL);
+			}/* else if (GETCHAR(1)=='<') {
+				r_chars++;
+				if (GETCHAR(2)=='=') {
+					r_chars++;
+					return Token(TK_OP_ASSIGN_SHIFT_RIGHT);
+				}
+
+				return Token(TK_OP_SHIFT_RIGHT);
+			}*/
+
+			return Token(TK_OP_GREATER);
+
+		} break;
+		case '!': {
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_NOT_EQUAL);
+			}
+
+			return Token(TK_OP_NOT);
+
+		} break;
+		//case '"' //string - no strings in shader
+		//case '\'' //string - no strings in shader
+		case '{':
+			return Token(TK_CURLY_BRACKET_OPEN);
+		case '}':
+			return Token(TK_CURLY_BRACKET_CLOSE);
+		//case '[':
+		//	return Token(TK_BRACKET_OPEN);
+		//case ']':
+	//		return Token(TK_BRACKET_CLOSE);
+		case '(':
+			return Token(TK_PARENTHESIS_OPEN);
+		case ')':
+			return Token(TK_PARENTHESIS_CLOSE);
+		case ',':
+			return Token(TK_COMMA);
+		case ';':
+			return Token(TK_SEMICOLON);
+		//case '?':
+		//	return Token(TK_QUESTION_MARK);
+		//case ':':
+		//	return Token(TK_COLON); //for methods maybe but now useless.
+		//case '^':
+		//	return Token(TK_OP_BIT_XOR);
+		//case '~':
+	//		return Token(TK_OP_BIT_INVERT);
+		case '&': {
+
+			if (GETCHAR(1)=='&') {
+
+				r_chars++;
+				return Token(TK_OP_AND);
+			}
+
+			return Token(TK_ERROR,"Unknown character");
+
+/*
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_BIT_AND);
+			} else if (GETCHAR(1)=='&') {
+				r_chars++;
+				return Token(TK_OP_AND);
+			}
+			return TK_OP_BIT_AND;*/
+		} break;
+		case '|': {
+
+			if (GETCHAR(1)=='|') {
+
+				r_chars++;
+				return Token(TK_OP_OR);
+			}
+
+			return Token(TK_ERROR,"Unknown character");
+
+			/*
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_BIT_OR);
+			} else if (GETCHAR(1)=='|') {
+				r_chars++;
+				return Token(TK_OP_OR);
+			}
+			return TK_OP_BIT_OR;
+			*/
+		} break;
+		case '*': {
+
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_MUL);
+			}
+			return TK_OP_MUL;
+		} break;
+		case '+': {
+
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_ADD);
+			}  /*else if (GETCHAR(1)=='+') {
+
+				r_chars++;
+				return Token(TK_OP_PLUS_PLUS);
+			}*/
+
+			return TK_OP_ADD;
+		} break;
+		case '-': {
+
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_SUB);
+			}/* else if (GETCHAR(1)=='-') {
+
+				r_chars++;
+				return Token(TK_OP_MINUS_MINUS);
+			}*/
+
+			return TK_OP_SUB;
+		} break;
+		/*case '%': {
+
+			if (GETCHAR(1)=='=') {
+				r_chars++;
+				return Token(TK_OP_ASSIGN_MOD);
+			}
+
+			return TK_OP_MOD;
+		} break;*/
+		default: {
+
+			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;
+
+				String str;
+				int i=0;
+
+				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') {
+						if (hexa_found || exponent_found)
+							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) {
+						if (sign_found)
+							return Token(TK_ERROR,"Invalid numeric constant");
+						sign_found=true;
+					} else
+						break;
+
+					str+=CharType(GETCHAR(i));
+					i++;
+				}
+
+				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);
+				/*
+				if (period_found)
+					return Token(TK_NUMBER_REAL,str);
+				else
+					return Token(TK_NUMBER_INTEGER,str);*/
+
+			}
+
+			if (GETCHAR(0)=='.') {
+				//parse period
+				return Token(TK_PERIOD);
+			}
+
+			if (_is_text_char(GETCHAR(0))) {
+				// parse identifier
+				String str;
+				str+=CharType(GETCHAR(0));
+
+				while(_is_text_char(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"},
+					/*{TK_TYPE_INT,"int"},
+					{TK_TYPE_INT2,"int2"},
+					{TK_TYPE_INT3,"int3"},
+					{TK_TYPE_INT4,"int4"},*/
+					{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_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_CF_FOR,"for"},
+					{TK_CF_WHILE,"while"},
+					{TK_CF_DO,"do"},
+					{TK_CF_SWITCH,"switch"},
+					{TK_CF_BREAK,"break"},
+					{TK_CF_CONTINUE,"continue"},*/
+					{TK_CF_RETURN,"return"},
+					{TK_UNIFORM,"uniform"},
+					{TK_ERROR,NULL}
+				};
+
+				int idx=0;
+
+				while(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_ERROR,"Unknown character");
+
+		} break;
+	}
+
+	ERR_PRINT("BUG");
+	return Token();
+}
+
+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 line=0;
+
+	while(pos<len) {
+
+		int advance=0;
+		int prev_line=line;
+		Token t = read_token(&p_text[pos],len-pos,line,advance);
+		t.line=prev_line;
+
+		if (t.type==TK_ERROR) {
+
+			if (r_error) {
+				return ERR_COMPILATION_FAILED;
+				*r_error=t.text;
+				*r_err_line=line;
+			}
+		}
+
+		if (t.type!=TK_EMPTY)
+			p_tokens->push_back(t);
+		//if (prev_line!=line)
+		//	p_tokens->push_back(Token(TK_LINE,itos(line)));
+
+		pos+=advance;
+
+	}
+
+	return OK;
+
+}
+
+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)
+		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";
+	}
+
+	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_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) {
+
+		case TK_TYPE_VOID: return TYPE_VOID;
+		case TK_TYPE_BOOL: return TYPE_BOOL;
+		case TK_TYPE_FLOAT: return TYPE_FLOAT;
+		case TK_TYPE_VEC2: return TYPE_VEC2;
+		case TK_TYPE_VEC3: return TYPE_VEC3;
+		case TK_TYPE_VEC4: return TYPE_VEC4;
+		case TK_TYPE_COLOR: return TYPE_VEC4;
+		case TK_TYPE_MAT3: return TYPE_MAT3;
+		case TK_TYPE_MAT4: return TYPE_MAT4;
+		case TK_TYPE_TEXTURE: return TYPE_TEXTURE;
+		case TK_TYPE_CUBEMAP: return TYPE_CUBEMAP;
+		default: return TYPE_VOID;
+	}
+
+	return TYPE_VOID;
+}
+
+
+String ShaderLanguage::get_datatype_name(DataType p_type) {
+
+	switch(p_type) {
+
+		case TYPE_VOID: return "void";
+		case TYPE_BOOL: return "bool";
+		case TYPE_FLOAT: return "float";
+		case TYPE_VEC2: return "vec2";
+		case TYPE_VEC3: return "vec3";
+		case TYPE_VEC4: return "vec4";
+		case TYPE_MAT3: return "mat3";
+		case TYPE_MAT4: return "mat4";
+		case TYPE_TEXTURE: return "texture";
+		case TYPE_CUBEMAP: return "cubemap";
+		default: return "";
+	}
+
+	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_MAT3) ||
+		(p_type==TK_TYPE_MAT4) ||
+		(p_type==TK_TYPE_TEXTURE) ||
+		(p_type==TK_TYPE_CUBEMAP);
+
+}
+
+
+bool ShaderLanguage::parser_is_at_function(Parser& parser) {
+
+	return (is_token_datatype(parser.get_token_type(0)) && parser.get_token_type(1)==TK_INDENTIFIER && parser.get_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) {
+
+	Node *node = p_node;
+
+	while(node) {
+
+		if (node->type==Node::TYPE_BLOCK) {
+
+			BlockNode *block = (BlockNode*)node;
+			if (block->variables.has(p_identifier))
+				return true;
+		} else if (node->type==Node::TYPE_PROGRAM) {
+
+			ProgramNode *program = (ProgramNode*)node;			
+			for(int i=0;i<program->functions.size();i++) {
+
+				if (program->functions[i].name==p_identifier) {
+					return true;
+				}
+			}
+
+			if(program->builtin_variables.has(p_identifier)) {
+				return true;
+			}
+			if(program->uniforms.has(p_identifier)) {
+				return true;
+			}
+
+		} 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)
+					return true;
+		}
+
+		node=node->parent;
+	}
+
+	// try keywords
+
+	int idx=0;
+
+	//todo optimize
+	while(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) {
+
+	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;
+
+	StringName name = parser.get_token(1).text;
+
+	if (test_existing_identifier(p_block,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->return_type=get_token_datatype(parser.get_token_type(0));
+
+	{ //add to programnode
+		ProgramNode::Function f;
+		f.name=name;
+		f.function=function;
+		program->functions.push_back(f);
+	}
+
+	int ofs=3;
+
+	while(true) {
+
+		//end of arguments
+		if (parser.get_token_type(ofs)==TK_PARENTHESIS_CLOSE) {
+			ofs++;
+			break;
+		}
+		//next argument awaits
+		if (parser.get_token_type(ofs)==TK_COMMA) {
+			if (!is_token_nonvoid_datatype(parser.get_token_type(ofs+1))) {
+				parser.set_error("Expected Identifier or ')' following ','");
+				return ERR_PARSE_ERROR;
+			}
+			ofs++;
+			continue;
+		}
+
+
+
+		if (!is_token_nonvoid_datatype(parser.get_token_type(ofs+0))) {
+			parser.set_error("Invalid Argument Type");
+			return ERR_PARSE_ERROR;
+		}
+
+		DataType identtype=get_token_datatype(parser.get_token_type(ofs+0));
+
+		if (parser.get_token_type(ofs+1)!=TK_INDENTIFIER) {
+			parser.set_error("Expected Argument Identifier");
+			return ERR_PARSE_ERROR;
+		}
+
+		StringName identname=parser.get_token(ofs+1).text;
+
+		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;
+		//function->body->variables[arg.name]=arg.type;
+		function->arguments.push_back(arg);
+
+		ofs+=2;
+	}
+
+	parser.advance(ofs);
+	// match {
+	if (parser.get_token_type()!=TK_CURLY_BRACKET_OPEN) {
+		parser.set_error("Expected '{'");
+		return ERR_PARSE_ERROR;
+	}
+
+	parser.advance();
+	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) {
+
+				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;
+				}
+			}
+		}
+
+		if (!found) {
+			parser.set_error("Function must return a value (use the main block)");
+			return ERR_PARSE_ERROR;
+		}
+	}
+
+	return OK;
+}
+
+
+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_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_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}},
+	{"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}},
+	//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}},
+	//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}},
+	{"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_VEC3,{TYPE_VEC3,TYPE_VEC3,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}},
+	//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}},
+
+	{NULL,TYPE_VOID,{TYPE_VOID}}
+
+};
+
+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_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_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_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_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_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_MAT3,TYPE_VEC2}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT4,TYPE_VEC2}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_VEC3}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC3,TYPE_FLOAT}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT3,TYPE_VEC3}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT4,TYPE_VEC3}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC4,TYPE_VEC4}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_VEC4,TYPE_FLOAT}},
+	{OP_ASSIGN_MUL,TYPE_VOID,{TYPE_MAT4,TYPE_VEC4}},
+	{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_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
+	{OP_CMP_EQ,TYPE_VEC2,{TYPE_VEC3,TYPE_VEC2}},
+	{OP_CMP_EQ,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
+	{OP_CMP_EQ,TYPE_VEC4,{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_FLOAT,{TYPE_FLOAT,TYPE_FLOAT}},
+	{OP_CMP_NEQ,TYPE_VEC3,{TYPE_VEC2,TYPE_VEC2}},
+	{OP_CMP_NEQ,TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3}},
+	{OP_CMP_NEQ,TYPE_VEC3,{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}}
+};
+
+
+const ShaderLanguage::BuiltinsDef ShaderLanguage::vertex_builtins_defs[]={
+
+	{ "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},
+	{ "INSTANCE_ID", TYPE_FLOAT},
+	{ "TIME", TYPE_FLOAT},
+	{ NULL, TYPE_VOID},
+};
+const ShaderLanguage::BuiltinsDef ShaderLanguage::fragment_builtins_defs[]={
+
+	{ "VERTEX", TYPE_VEC3},
+	{ "POSITION", TYPE_VEC3},
+	{ "NORMAL", TYPE_VEC3},
+	{ "TANGENT", TYPE_VEC3},
+	{ "BINORMAL", TYPE_VEC3},
+	{ "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_FLOAT},
+	{ "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}
+
+};
+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}
+};
+
+
+
+ShaderLanguage::DataType ShaderLanguage::compute_node_type(Node *p_node) {
+
+	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_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_CONTROL_FLOW: ERR_FAIL_V(TYPE_VOID);
+		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) {
+
+	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 );
+
+	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;
+		args.push_back(compute_node_type(p_func->arguments[i]));
+	}
+
+	int argcount=args.size();
+
+	bool found_intrinsic=false;
+
+	if (argcount<=4) {
+		// test intrinsics
+		int idx=0;
+
+		while (intrinsic_func_defs[idx].name) {
+
+			if (name==intrinsic_func_defs[idx].name) {
+
+				bool fail=false;
+				for(int i=0;i<argcount;i++) {
+
+					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) {
+					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) {
+
+			bool all_const=false;
+			Vector<float> cdata;
+			for(int i=0;i<argcount;i++) {
+
+				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;
+					default: ERR_FAIL_V(NULL);
+
+				}
+
+			}
+
+			ConstantNode *cn = parser.create_node<ConstantNode>(p_func->parent);
+			Variant data;
+			switch(p_func->return_cache) {
+				case TYPE_FLOAT: data = cdata[0]; break;
+				case TYPE_VEC2: data = Vector2(cdata[0],cdata[1]); break;
+				case TYPE_VEC3: data = Vector3(cdata[0],cdata[1],cdata[2]); break;
+				case TYPE_VEC4: data = Plane(cdata[0],cdata[1],cdata[2],cdata[3]); break;
+			}
+
+			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)
+
+
+	Node *node = p_func;
+
+	while(node->parent) {
+
+		if (node->type==Node::TYPE_FUNCTION) {
+
+			exclude_function = (FunctionNode*)node;
+		}
+
+		node=node->parent;
+	}
+
+	ERR_FAIL_COND_V(node->type!=Node::TYPE_PROGRAM,NULL);
+	ProgramNode *program = (ProgramNode*)node;
+
+	for(int i=0;i<program->functions.size();i++) {
+
+		if (program->functions[i].function==exclude_function)
+			continue;
+
+		FunctionNode *pfunc = program->functions[i].function;
+
+		if (pfunc->arguments.size()!=args.size())
+			continue;
+
+		bool fail=false;
+
+		for(int i=0;i<args.size();i++) {
+			if (args[i]!=pfunc->arguments[i].type) {
+				fail=true;
+				break;
+			}
+		}
+
+		if (!fail) {
+			p_func->return_cache=pfunc->return_type;
+			return p_func;
+		}
+	}
+
+	return NULL;
+}
+
+
+ShaderLanguage::Node * ShaderLanguage::validate_operator(Parser& parser,OperatorNode *p_func) {
+
+	int argcount = p_func->arguments.size();
+	ERR_FAIL_COND_V(argcount>2,NULL);
+
+	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;
+
+	}
+	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]) {
+
+				p_func->return_cache=operator_defs[idx].rettype;
+				valid=true;
+				break;
+			}
+		}
+
+		idx++;
+	}
+
+	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 _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);
+			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);
+
+}
+ShaderLanguage::Operator ShaderLanguage::get_token_operator(TokenType p_type) {
+
+	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 ;
+		default: ERR_FAIL_V(OP_MAX);
+	}
+
+	return OP_MAX;
+}
+
+
+Error ShaderLanguage::parse_expression(Parser& parser,Node *p_parent,Node **r_expr) {
+
+	Vector<Node*> expressions;
+	Vector<TokenType> operators;
+
+	while(true) {
+
+		Node *expr=NULL;
+
+
+		if (parser.get_token_type()==TK_PARENTHESIS_OPEN) {
+			//handle subexpression
+			parser.advance();
+			Error err = parse_expression(parser,p_parent,&expr);
+			if (err)
+				return err;
+
+			if (parser.get_token_type()!=TK_PARENTHESIS_CLOSE) {
+
+				parser.set_error("Expected ')' in expression");
+				return ERR_PARSE_ERROR;
+			}
+
+			parser.advance();
+
+		} else if (parser.get_token_type()==TK_REAL_CONSTANT) {
+
+
+			ConstantNode *constant = parser.create_node<ConstantNode>(p_parent);
+			constant->value=parser.get_token().text.operator String().to_double();
+			constant->datatype=TYPE_FLOAT;
+			expr=constant;
+			parser.advance();
+		} else if (parser.get_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;
+			parser.advance();
+		} else if (parser.get_token_type()==TK_FALSE) {
+
+			//handle false constant
+			ConstantNode *constant = parser.create_node<ConstantNode>(p_parent);
+			constant->value=false;
+			constant->datatype=TYPE_BOOL;
+			expr=constant;
+			parser.advance();
+		} else if (parser.get_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_token_type(1)==TK_PARENTHESIS_OPEN && (is_token_nonvoid_datatype(parser.get_token_type()) || parser.get_token_type()==TK_INDENTIFIER)) {
+
+
+			//function or constructor
+			StringName name;
+			DataType constructor=TYPE_VOID;
+			if (is_token_nonvoid_datatype(parser.get_token_type())) {
+
+				constructor=get_token_datatype(parser.get_token_type());
+				switch(get_token_datatype(parser.get_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_MAT3: name="mat3"; break;
+				   case TYPE_MAT4: name="mat4"; break;
+				   default: ERR_FAIL_V(ERR_BUG);
+				}
+			} else {
+
+				name=parser.get_token().text;
+			}
+
+			if (!test_existing_identifier(p_parent,name)) {
+
+				parser.set_error("Unknown identifier in expression: "+name);
+				return ERR_PARSE_ERROR;
+			}
+
+			parser.advance(2);
+
+			OperatorNode *func = parser.create_node<OperatorNode>(p_parent);
+
+			func->op=constructor!=TYPE_VOID?OP_CONSTRUCT:OP_CALL;
+
+			VariableNode *funcname = parser.create_node<VariableNode>(func);
+			funcname->name=name;
+			func->arguments.push_back(funcname);
+
+			//parse parameters
+
+			if (parser.get_token_type()==TK_PARENTHESIS_CLOSE) {
+				parser.advance();
+			} else {
+
+				while(true) {
+
+
+					Node *arg=NULL;
+					Error err = parse_expression(parser,func,&arg);
+					if (err)
+						return err;
+					func->arguments.push_back(arg);
+
+					if (parser.get_token_type()==TK_PARENTHESIS_CLOSE) {
+						parser.advance();
+						break;
+
+					} else if (parser.get_token_type()==TK_COMMA) {
+
+						if (parser.get_token_type(1)==TK_PARENTHESIS_CLOSE) {
+
+							parser.set_error("Expression expected");
+							return ERR_PARSE_ERROR;
+						}
+
+						parser.advance();
+					} else {
+						// something is broken
+						parser.set_error("Expected ',' or ')'");
+						return ERR_PARSE_ERROR;
+					}
+
+				}
+			}
+
+			expr=validate_function_call(parser,func);
+			if (!expr) {
+
+				parser.set_error("Invalid arguments to function/constructor: "+StringName(name));
+				return ERR_PARSE_ERROR;
+
+			}
+
+		} else if (parser.get_token_type()==TK_INDENTIFIER) {
+			//probably variable
+
+
+			Node *node =p_parent;
+			bool existing=false;
+			DataType datatype;
+			StringName identifier=parser.get_token().text;
+
+			while(node) {
+
+				if (node->type==Node::TYPE_BLOCK) {
+
+					BlockNode *block = (BlockNode*)node;
+
+					if (block->variables.has(identifier)) {
+						existing=true;
+						datatype=block->variables[identifier];
+						break;
+					}
+				}
+
+				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;
+							break;
+						}
+					}
+
+					if (existing)
+						break;
+
+				}
+
+				if (node->type==Node::TYPE_PROGRAM) {
+
+					ProgramNode *program = (ProgramNode*)node;
+					if (program->builtin_variables.has(identifier)) {
+						datatype = program->builtin_variables[identifier];
+						existing=true;
+						break;
+					}
+					if (program->uniforms.has(identifier)) {
+						datatype = program->uniforms[identifier].type;
+						existing=true;
+						break;
+					}
+
+				}
+
+				node=node->parent;
+			}
+
+			if (!existing) {
+
+				parser.set_error("Unexisting identifier in expression: "+identifier);
+				return ERR_PARSE_ERROR;
+
+			}
+
+			VariableNode *varname = parser.create_node<VariableNode>(p_parent);
+			varname->name=identifier;
+			varname->datatype_cache=datatype;
+			parser.advance();
+			expr=varname;
+
+		} else if (parser.get_token_type()==TK_OP_NEG || parser.get_token_type()==TK_OP_NOT) {
+
+			//single prefix operators
+			TokenType token_type=parser.get_token_type();
+			parser.advance();
+			Node *subexpr=NULL;
+			Error err = parse_expression(parser,p_parent,&subexpr);
+			if (err)
+				return err;
+
+			OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
+			switch(token_type) {
+				case TK_OP_NEG: op->op=OP_NEG; break;
+				case TK_OP_NOT: op->op=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);
+			}
+
+			op->arguments.push_back(subexpr);
+
+			expr=validate_operator(parser,op);
+
+			if (!expr) {
+
+				parser.set_error("Invalid argument for negation operator");
+				return ERR_PARSE_ERROR;
+			}
+
+		} else {
+			print_line("found bug?");
+			print_line("misplaced token: "+String(token_names[parser.get_token_type()]));
+
+			parser.set_error("Error parsing expression, misplaced: "+String(token_names[parser.get_token_type()]));
+			return ERR_PARSE_ERROR;
+			//nothing
+		}
+
+		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_token_type()==TK_PERIOD) {
+
+			if (parser.get_token_type(1)!=TK_INDENTIFIER) {
+				parser.set_error("Expected identifier as member");
+				return ERR_PARSE_ERROR;
+			}
+
+			DataType dt = compute_node_type(expr);
+			String ident = parser.get_token(1).text;
+
+			bool ok=true;
+			DataType member_type;
+			switch(dt) {
+				case TYPE_VEC2: {
+
+					int l = ident.length();
+					if (l==1) {
+						member_type=TYPE_FLOAT;
+					} else if (l==2) {
+						member_type=TYPE_VEC2;
+					} else {
+						ok=false;
+						break;
+					}
+
+					const CharType *c=ident.ptr();
+					for(int i=0;i<l;i++) {
+
+						switch(c[i]) {
+							case 'r':
+							case 'g':
+							case 'x':
+							case 'y':
+								break;
+							default:
+								ok=false;
+								break;
+						}
+					}
+
+				} break;
+				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;
+					} else {
+						ok=false;
+						break;
+					}
+
+					const CharType *c=ident.ptr();
+					for(int i=0;i<l;i++) {
+
+						switch(c[i]) {
+							case 'r':
+							case 'g':
+							case 'b':
+							case 'x':
+							case 'y':
+							case 'z':
+								break;
+							default:
+								ok=false;
+								break;
+						}
+					}
+
+				} break;
+				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;
+					} else {
+						ok=false;
+						break;
+					}
+
+					const CharType *c=ident.ptr();
+					for(int i=0;i<l;i++) {
+
+						switch(c[i]) {
+							case 'r':
+							case 'g':
+							case 'b':
+							case 'a':
+							case 'x':
+							case 'y':
+							case 'z':
+							case 'w':
+								break;
+							default:
+								ok=false;
+								break;
+						}
+					}
+
+				} 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);
+				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;
+
+			parser.advance(2);
+			//todo
+			//member (period) has priority over any operator
+			//creates a subindexing expression in place
+
+
+		} else if (parser.get_token_type()==TK_BRACKET_OPEN) {
+			//todo
+			//subindexing has priority over any operator
+			//creates a subindexing expression in place
+
+
+		} /*else if (parser.get_token_type()==TK_OP_PLUS_PLUS || parser.get_token_type()==TK_OP_MINUS_MINUS) {
+			//todo
+			//inc/dec operators have priority over any operator
+			//creates a subindexing expression in place
+			//return OK; //wtfs
+
+		} */
+
+
+		expressions.push_back(expr);
+
+
+		if (is_token_operator(parser.get_token_type())) {
+
+			operators.push_back(parser.get_token_type());
+			parser.advance();
+		} else {
+			break;
+		}
+	}
+
+	ERR_FAIL_COND_V(expressions.size()!=(operators.size()+1),ERR_BUG);
+
+	/* Reduce the set set of expressions and place them in an operator tree, respecting precedence */
+
+	while(expressions.size()>1) {
+
+		int next_op=-1;
+		int min_priority=0xFFFFF;
+
+		for(int i=0;i<operators.size();i++) {
+
+			int priority;
+			switch(operators[i]) {
+
+				case TK_OP_MUL: priority=0; break;
+				case TK_OP_DIV: priority=0; break;
+
+				case TK_OP_ADD: priority=1; break;
+				case TK_OP_SUB: priority=1; break;
+
+				// shift left/right =2
+
+				case TK_OP_LESS: priority=3; break;
+				case TK_OP_LESS_EQUAL: priority=3; break;
+				case TK_OP_GREATER: priority=3; break;
+				case TK_OP_GREATER_EQUAL: priority=3; break;
+
+				case TK_OP_EQUAL: priority=4; break;
+				case TK_OP_NOT_EQUAL: priority=4; break;
+
+				//bit and =5
+				//bit xor =6
+				//bit or=7
+
+				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
+
+			}
+
+			if (priority<min_priority) {
+				// < is used for left to right (default)
+				// <= is used for right to left
+				next_op=i;
+				min_priority=priority;
+			}
+
+		}
+
+		ERR_FAIL_COND_V(next_op==-1,ERR_BUG);
+
+		// OK! create operator..
+
+		OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
+		op->op=get_token_operator(operators[next_op]);
+
+		op->arguments.push_back(expressions[next_op]); //expression goes as left
+		op->arguments.push_back(expressions[next_op+1]); //next expression goes as right
+
+		expressions[next_op]=validate_operator(parser,op);
+		if (!expressions[next_op]) {
+
+			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]));
+
+			}
+			parser.set_error("Invalid arguments to operator "+String(token_names[operators[next_op]])+": "+at);
+			return ERR_PARSE_ERROR;
+		}
+
+
+		expressions.remove(next_op+1);
+		operators.remove(next_op);
+
+	}
+
+	*r_expr=expressions[0];
+
+	return OK;
+
+/*
+			TokenType token_type=parser.get_token_type();
+			OperatorNode *op = parser.create_node<OperatorNode>(p_parent);
+			op->op=get_token_operator(parser.get_token_type());
+
+			op->arguments.push_back(*r_expr); //expression goes as left
+			parser.advance();
+			Node *right_expr=NULL;
+			Error err = parse_expression(parser,p_parent,&right_expr);
+			if (err)
+				return err;
+			op->arguments.push_back(right_expr);
+
+			if (!validate_operator(op)) {
+
+				parser.set_error("Invalid arguments to operator "+String(token_names[token_type]));
+				return ERR_PARSE_ERROR;
+			}
+
+*/
+
+}
+
+Error ShaderLanguage::parse_variable_declaration(Parser& parser,BlockNode *p_block) {
+
+	bool uniform = parser.get_token(-1).type==TK_UNIFORM;
+
+	DataType type=get_token_datatype(parser.get_token_type(0));
+	bool iscolor = parser.get_token_type(0)==TK_TYPE_COLOR;
+
+	if (type==TYPE_VOID) {
+
+		parser.set_error("Cannot Declare a 'void' Variable");
+		return ERR_PARSE_ERROR;
+	}
+
+	if (type==TYPE_TEXTURE && !uniform) {
+
+		parser.set_error("Cannot Declare a Non-Uniform Texture");
+		return ERR_PARSE_ERROR;
+	}
+	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) {
+
+
+		if (found && parser.get_token_type()!=TK_COMMA) {
+			break;
+		}
+
+		if (parser.get_token_type()!=TK_INDENTIFIER) {
+
+			parser.set_error("Identifier Expected");
+			return ERR_PARSE_ERROR;
+
+		}
+
+		StringName name = parser.get_token().text;
+
+		if (test_existing_identifier(p_block,name)) {
+			parser.set_error("Duplicate Identifier (existing variable/function): "+name);
+			return ERR_PARSE_ERROR;
+		}
+
+		found=true;
+
+		parser.advance();
+		//see if declaration has an initializer
+		if (parser.get_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;
+			Node *expr;
+			Error err = parse_expression(parser,p_block,&expr);
+
+			if (err)
+				return err;
+
+			if (var->uniform) {
+
+				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) {
+					Color c;
+					Plane p = u.default_value;
+					c=Color(p.normal.x,p.normal.y,p.normal.z,p.d);
+					u.default_value=c;
+				}
+				parser.program->uniforms[var->name]=u;
+			} else {
+				op->op=OP_ASSIGN;
+				op->arguments.push_back(var);
+				op->arguments.push_back(expr);
+				Node *n=validate_operator(parser,op);
+				if (!n) {
+					parser.set_error("Invalid initializer for variable: "+name);
+					return ERR_PARSE_ERROR;
+				}
+				p_block->statements.push_back(n);
+			}
+
+		} 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);
+
+			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_MAT3: con->value=Matrix3(); break;
+				case TYPE_MAT4: con->value=Transform(); break;
+				case TYPE_TEXTURE:
+				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;
+
+			} else {
+				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;
+
+	}
+
+	if (parser.get_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) {
+
+	ControlFlowNode *cf = parser.create_node<ControlFlowNode>(p_parent);
+
+	cf->flow_op=FLOW_OP_IF;
+
+	parser.advance();
+
+	if (parser.get_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);
+	if (err)
+		return err;
+
+	if (compute_node_type(expression)!=TYPE_BOOL) {
+
+		parser.set_error("Expression for 'if' is not boolean");
+		return ERR_PARSE_ERROR;
+	}
+
+	cf->statements.push_back(expression);
+
+	if (parser.get_token_type()!=TK_PARENTHESIS_CLOSE) {
+		parser.set_error("Expected ')' after expression");
+		return ERR_PARSE_ERROR;
+	}
+
+	parser.advance();
+
+	Node *substatement=NULL;
+	err = parse_statement(parser,cf,&substatement);
+	if (err)
+		return err;
+
+
+	cf->statements.push_back(substatement);
+
+
+
+	if (parser.get_token_type()==TK_CF_ELSE) {
+
+		parser.advance();
+		substatement=NULL;
+		err = parse_statement(parser,cf,&substatement);
+		if (err)
+			return err;
+
+		cf->statements.push_back(substatement);
+	}
+
+
+
+	*r_statement=cf;
+
+	return OK;
+}
+
+Error ShaderLanguage::parse_flow_return(Parser& parser,Node *p_parent,Node **r_statement) {
+
+
+	FunctionNode *function=NULL;
+
+	Node *parent=p_parent;
+
+	while(parent) {
+
+		if (parent->type==Node::TYPE_FUNCTION) {
+
+			function=(FunctionNode*)parent;
+			break;
+		}
+
+		parent=parent->parent;
+	}
+
+	if (!function) {
+
+		parser.set_error("'return' must be inside a function");
+		return ERR_PARSE_ERROR;
+	}
+
+	ControlFlowNode *cf = parser.create_node<ControlFlowNode>(p_parent);
+
+	cf->flow_op=FLOW_OP_RETURN;
+
+	parser.advance();
+
+	if (function->return_type!=TYPE_VOID) {
+		// should expect a return expression.
+
+		Node *expr=NULL;
+		Error err = parse_expression(parser,cf,&expr);
+		if (err)
+			return err;
+
+		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;
+
+
+	if (parser.get_token_type()!=TK_SEMICOLON) {
+		parser.set_error("Expected ';'");
+		return ERR_PARSE_ERROR;
+	}
+
+	return OK;
+}
+
+Error ShaderLanguage::parse_statement(Parser& parser,Node *p_parent,Node **r_statement) {
+
+	*r_statement=NULL;
+
+	TokenType token_type = parser.get_token_type();
+
+	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) {
+		// 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_RETURN) {
+		return parse_flow_return(parser,p_parent,r_statement);
+	} else {
+		Error err=parse_expression(parser,p_parent,r_statement);
+
+		if (err)
+			return err;
+
+		if (parser.get_token_type()!=TK_SEMICOLON) {
+			parser.set_error("Expected ';'");
+			return ERR_PARSE_ERROR;
+		}
+
+	}
+
+	return OK;
+}
+
+Error ShaderLanguage::parse_block(Parser& parser,BlockNode *p_block) {
+
+	while(true) {
+
+		if (parser.is_at_end()) {
+			if (p_block->parent->type!=Node::TYPE_PROGRAM) {
+				parser.set_error("Unexpected End of File");
+				return ERR_PARSE_ERROR;
+			}
+			return OK; //bye
+		}
+
+		TokenType token_type = parser.get_token_type();
+
+		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) {
+
+			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);
+			if (err)
+				return err;
+
+		} else if (is_token_datatype(token_type)) {
+
+			Error err=OK;
+			if (parser_is_at_function(parser))
+				err = parse_function(parser,p_block);
+			else {
+				err = parse_variable_declaration(parser,p_block);
+			}
+
+			if (err)
+				return err;
+
+		} else {
+			// must be a statement
+			Node *statement=NULL;
+
+			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) {
+
+
+	uint64_t t = OS::get_singleton()->get_ticks_usec();
+
+	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)	{
+		case SHADER_MATERIAL_VERTEX: {
+			int idx=0;
+			while (vertex_builtins_defs[idx].name) {
+				parser.program->builtin_variables[vertex_builtins_defs[idx].name]=vertex_builtins_defs[idx].type;
+				idx++;
+			}
+		} break;
+		case SHADER_MATERIAL_FRAGMENT: {
+			int idx=0;
+			while (fragment_builtins_defs[idx].name) {
+				parser.program->builtin_variables[fragment_builtins_defs[idx].name]=fragment_builtins_defs[idx].type;
+				idx++;
+			}
+		} break;
+		case SHADER_POST_PROCESS: {
+			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;
+				idx++;
+			}
+		} break;
+	}
+
+	Error err = parse_block(parser,parser.program->body);
+	if (err) {
+		parser.get_error(r_error,r_err_line,r_err_column);
+		return err;
+	}
+
+	double tf = (OS::get_singleton()->get_ticks_usec()-t)/1000.0;
+	//print_line("parse time: "+rtos(tf));
+
+	t = OS::get_singleton()->get_ticks_usec();
+
+	if (p_compile_func)
+		p_compile_func(p_userdata,parser.program);
+
+	tf = (OS::get_singleton()->get_ticks_usec()-t)/1000.0;
+	//print_line("compile time: "+rtos(tf));
+
+	//clean up nodes created
+	while(parser.nodegc.size()) {
+
+		memdelete( parser.nodegc.front()->get() );
+		parser.nodegc.pop_front();
+	}
+	return OK;
+}
+
+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;
+	Vector<Token> tokens;
+
+	uint64_t t = OS::get_singleton()->get_ticks_usec();
+
+	Error err = tokenize(p_code,&tokens,r_error,r_err_line,r_err_column);
+
+	double tf = (OS::get_singleton()->get_ticks_usec()-t)/1000.0;
+	//print_line("tokenize time: "+rtos(tf));
+
+	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) {
+		//print_line("LDEBUG: "+lex_debug(p_code));
+		return err;
+	}
+	return OK;
+}
+
+
+void ShaderLanguage::get_keyword_list(ShaderType p_type, List<String> *p_keywords) {
+
+	int idx=0;
+
+	while(intrinsic_func_defs[idx].name) {
+
+		p_keywords->push_back(intrinsic_func_defs[idx].name);
+		idx++;
+	}
+
+	switch(p_type)	{
+		case SHADER_MATERIAL_VERTEX: {
+			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;
+			while (fragment_builtins_defs[idx].name) {
+				p_keywords->push_back(fragment_builtins_defs[idx].name);
+				idx++;
+			}
+		} break;
+		case SHADER_POST_PROCESS: {
+			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
new file mode 100644
index 0000000000..9455e677cf
--- /dev/null
+++ b/servers/visual/shader_language.h
@@ -0,0 +1,403 @@
+/*************************************************************************/
+/*  shader_language.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#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 "variant.h"
+
+
+class ShaderLanguage  {
+public:
+
+
+	/* COMPILER */
+
+	enum ShaderType {
+		SHADER_MATERIAL_VERTEX,
+		SHADER_MATERIAL_FRAGMENT,
+		SHADER_POST_PROCESS,
+	};
+
+	enum DataType {
+		TYPE_VOID,
+		TYPE_BOOL,
+		TYPE_FLOAT,
+		TYPE_VEC2,
+		TYPE_VEC3,
+		TYPE_VEC4,
+		TYPE_MAT3,
+		TYPE_MAT4,
+		TYPE_TEXTURE,
+		TYPE_CUBEMAP,
+	};
+
+	enum Operator {
+		OP_ASSIGN,
+		OP_ADD,
+		OP_SUB,
+		OP_MUL,
+		OP_DIV,
+		OP_ASSIGN_ADD,
+		OP_ASSIGN_SUB,
+		OP_ASSIGN_MUL,
+		OP_ASSIGN_DIV,
+		OP_NEG,
+		OP_NOT,
+		OP_CMP_EQ,
+		OP_CMP_NEQ,
+		OP_CMP_LEQ,
+		OP_CMP_GEQ,
+		OP_CMP_LESS,
+		OP_CMP_GREATER,
+		OP_CMP_OR,
+		OP_CMP_AND,
+		OP_CALL,
+		OP_CONSTRUCT,
+		OP_MAX
+	};
+
+	enum FlowOperation {
+		FLOW_OP_IF,
+		FLOW_OP_RETURN,
+		//FLOW_OP_FOR,
+		//FLOW_OP_WHILE,
+		//FLOW_OP_DO,
+		//FLOW_OP_BREAK,
+		//FLOW_OP_CONTINUE,
+
+	};
+
+	struct Node {
+
+		enum Type {
+			TYPE_PROGRAM,
+			TYPE_FUNCTION,
+			TYPE_BLOCK,
+			TYPE_VARIABLE,
+			TYPE_CONSTANT,
+			TYPE_OPERATOR,
+			TYPE_CONTROL_FLOW,
+			TYPE_MEMBER
+		};
+
+		Node * parent;
+		Type type;
+
+		virtual DataType get_datatype() const { return TYPE_VOID; }
+
+		virtual ~Node() {}
+	};
+
+
+	struct OperatorNode : public Node {
+
+		DataType return_cache;
+		Operator op;
+		Vector<Node*> arguments;
+		virtual DataType get_datatype() const { return return_cache; }
+
+		OperatorNode() { type=TYPE_OPERATOR; return_cache=TYPE_VOID; }
+	};
+
+	struct VariableNode : public Node {
+		bool uniform;
+		DataType datatype_cache;
+		StringName name;
+		virtual DataType get_datatype() const { return datatype_cache; }
+
+		VariableNode() { type=TYPE_VARIABLE; datatype_cache=TYPE_VOID; uniform=false; }
+	};
+
+	struct ConstantNode : public Node {
+
+		DataType datatype;
+		Variant value;
+		virtual DataType get_datatype() const { return datatype; }
+
+		ConstantNode() { type=TYPE_CONSTANT; }
+	};
+
+	struct BlockNode : public Node {
+
+		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;}
+	};
+
+	struct MemberNode : public Node {
+
+		DataType basetype;
+		DataType datatype;
+		StringName name;
+		Node* owner;
+		virtual DataType get_datatype() const { return datatype; }
+		MemberNode() { type=TYPE_MEMBER; }
+	};
+
+
+	struct FunctionNode : public Node {
+
+
+		struct Argument {
+
+			StringName name;
+			DataType type;
+		};
+
+		StringName name;
+		DataType return_type;
+		Vector<Argument> arguments;
+		BlockNode *body;
+
+		FunctionNode() { type=TYPE_FUNCTION;  }
+
+	};
+
+	struct Uniform {
+
+		int order;
+		DataType type;
+		Variant default_value;
+	};
+
+	struct ProgramNode : public Node {
+
+		struct Function {
+			StringName name;
+			FunctionNode*function;
+		};
+
+
+		Map<StringName,DataType> builtin_variables;
+		Map<StringName,Uniform> uniforms;
+
+		Vector<Function> functions;
+		BlockNode *body;
+
+		ProgramNode() { type=TYPE_PROGRAM; }
+	};
+
+	typedef void (*CompileFunc)(void*,ProgramNode*);
+
+	struct VarInfo {
+
+		StringName name;
+		DataType type;
+	};
+
+private:
+
+
+
+	enum TokenType {
+
+		TK_EMPTY,
+		TK_INDENTIFIER,
+		TK_TRUE,
+		TK_FALSE,
+		TK_REAL_CONSTANT,
+		TK_TYPE_VOID,
+		TK_TYPE_BOOL,
+		TK_TYPE_FLOAT,
+		TK_TYPE_VEC2,
+		TK_TYPE_VEC3,
+		TK_TYPE_VEC4,
+		TK_TYPE_MAT3,
+		TK_TYPE_MAT4,
+		TK_TYPE_TEXTURE,
+		TK_TYPE_CUBEMAP,
+		TK_TYPE_COLOR,
+		TK_OP_EQUAL,
+		TK_OP_NOT_EQUAL,
+		TK_OP_LESS,
+		TK_OP_LESS_EQUAL,
+		TK_OP_GREATER,
+		TK_OP_GREATER_EQUAL,
+		TK_OP_AND,
+		TK_OP_OR,
+		TK_OP_NOT,
+		TK_OP_ADD,
+		TK_OP_SUB,
+		TK_OP_MUL,
+		TK_OP_DIV,
+		TK_OP_NEG,
+		TK_OP_ASSIGN,
+		TK_OP_ASSIGN_ADD,
+		TK_OP_ASSIGN_SUB,
+		TK_OP_ASSIGN_MUL,
+		TK_OP_ASSIGN_DIV,
+		TK_CF_IF,
+		TK_CF_ELSE,
+		TK_CF_RETURN,
+		TK_BRACKET_OPEN,
+		TK_BRACKET_CLOSE,
+		TK_CURLY_BRACKET_OPEN,
+		TK_CURLY_BRACKET_CLOSE,
+		TK_PARENTHESIS_OPEN,
+		TK_PARENTHESIS_CLOSE,
+		TK_COMMA,
+		TK_SEMICOLON,
+		TK_PERIOD,
+		TK_UNIFORM,
+		TK_ERROR,		
+		TK_MAX
+	};
+
+	static const char * token_names[TK_MAX];
+
+	struct Token {
+
+		TokenType type;
+		StringName text;
+		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; }
+	};
+
+
+
+	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; }
+		void get_error(String *r_error, int *r_line, int *r_column) {
+
+			*r_error=error;
+			*r_line=get_token(pos).line;
+			*r_column=get_token(pos).col;
+		}
+
+
+
+		Token get_token(int ofs=0) const { int idx=pos+ofs; if (idx<0 || idx>=tokens.size()) return Token(TK_ERROR); return tokens[idx]; }
+		TokenType get_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;
+
+		Parser(const Vector<Token>& p_tokens) { tokens=p_tokens; pos=0;}
+	};
+
+	struct IntrinsicFuncDef {
+
+		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 };
+		Operator op;
+		DataType rettype;
+		const DataType args[MAX_ARGS];
+	};
+
+	static const OperatorDef operator_defs[];
+
+	struct BuiltinsDef {
+
+		const char* name;
+		DataType type;
+	};
+
+	static const BuiltinsDef vertex_builtins_defs[];
+	static const BuiltinsDef fragment_builtins_defs[];
+	static const BuiltinsDef postprocess_fragment_builtins_defs[];
+
+	static DataType get_token_datatype(TokenType p_type);
+	static String get_datatype_name(DataType p_type);
+	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 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 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_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);
+
+;
+public:
+
+	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);
+
+};
+
+
+#endif // SHADER_LANGUAGE_H
diff --git a/servers/visual/visual_server_raster.cpp b/servers/visual/visual_server_raster.cpp
new file mode 100644
index 0000000000..42b8d484b5
--- /dev/null
+++ b/servers/visual/visual_server_raster.cpp
@@ -0,0 +1,5717 @@
+/*************************************************************************/
+/*  visual_server_raster.cpp                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* 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"
+// careful, these may run in different threads than the visual server
+
+BalloonAllocator<> *VisualServerRaster::OctreeAllocator::allocator=NULL;
+
+#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) {
+
+	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)  {
+
+	VS_CHANGED;
+	rasterizer->texture_set_flags(p_texture,p_flags);
+}
+
+
+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);
+
+
+}
+
+Image VisualServerRaster::texture_get_data(RID p_texture,CubeMapSide p_cube_side) const {
+
+
+	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 {
+
+	return rasterizer->texture_get_width(p_texture);
+}
+
+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) {
+
+	rasterizer->texture_set_size_override(p_texture,p_width,p_height);
+}
+
+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 {
+
+	rasterizer->texture_set_reload_hook(p_texture,p_owner,p_function);
+}
+
+/* SHADER API */
+
+RID VisualServerRaster::shader_create(ShaderMode p_mode) {
+
+	return rasterizer->shader_create(p_mode);
+}
+
+void VisualServerRaster::shader_set_mode(RID p_shader,ShaderMode p_mode){
+
+	VS_CHANGED;
+	rasterizer->shader_set_mode(p_shader,p_mode);
+}
+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,int p_vertex_ofs,int p_fragment_ofs) {
+
+	VS_CHANGED;
+	rasterizer->shader_set_code(p_shader,p_vertex,p_fragment,p_vertex_ofs,p_fragment_ofs);
+}
+
+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{
+
+	return rasterizer->shader_get_fragment_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);
+}
+
+
+
+/* Material */
+
+RID VisualServerRaster::material_create() {
+
+	return rasterizer->material_create();
+}
+
+void VisualServerRaster::material_set_shader(RID p_material, RID p_shader) {
+
+	VS_CHANGED;
+	rasterizer->material_set_shader(p_material, p_shader );
+}
+
+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) {
+
+	VS_CHANGED;
+	rasterizer->material_set_param(p_material, p_param,p_value );
+}
+
+Variant VisualServerRaster::material_get_param(RID p_material, const StringName& p_param) const {
+
+	return rasterizer->material_get_param(p_material,p_param);
+}
+
+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);
+}
+
+void VisualServerRaster::material_set_hint(RID p_material, MaterialHint p_hint,bool p_enabled) {
+
+	VS_CHANGED;
+	rasterizer->material_set_hint(p_material,p_hint,p_enabled);
+}
+
+bool VisualServerRaster::material_get_hint(RID p_material,MaterialHint p_hint) const {
+
+	return rasterizer->material_get_hint(p_material,p_hint);
+
+}
+
+void VisualServerRaster::material_set_shade_model(RID p_material, MaterialShadeModel p_model) {
+	VS_CHANGED;
+	rasterizer->material_set_shade_model(p_material,p_model);
+}
+
+VisualServer::MaterialShadeModel VisualServerRaster::material_get_shade_model(RID p_material) const {
+
+	return rasterizer->material_get_shade_model(p_material);
+
+}
+
+
+bool VisualServerRaster::material_get_flag(RID p_material,MaterialFlag p_flag) const {
+
+	return rasterizer->material_get_flag(p_material,p_flag);
+}
+
+void VisualServerRaster::material_set_blend_mode(RID p_material,MaterialBlendMode p_mode) {
+	VS_CHANGED;
+	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) {
+	VS_CHANGED;
+	rasterizer->material_set_line_width(p_material,p_line_width);
+}
+float VisualServerRaster::material_get_line_width(RID p_material) const {
+
+	return rasterizer->material_get_line_width(p_material);
+}
+
+/* FIXED MATERIAL */
+
+RID VisualServerRaster::fixed_material_create() {
+
+	return rasterizer->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);
+}
+
+bool VisualServerRaster::fixed_material_get_flag(RID p_material, FixedMaterialFlags p_flag) const {
+
+	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) {
+	VS_CHANGED;
+	rasterizer->fixed_material_set_parameter(p_material,p_parameter,p_value);
+}
+
+Variant VisualServerRaster::fixed_material_get_param(RID p_material,FixedMaterialParam p_parameter) const {
+
+	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) {
+	VS_CHANGED;
+	rasterizer->fixed_material_set_texture(p_material,p_parameter,p_texture);
+}
+
+RID VisualServerRaster::fixed_material_get_texture(RID p_material,FixedMaterialParam p_parameter) const {
+
+	return rasterizer->fixed_material_get_texture(p_material,p_parameter);
+}
+
+
+void VisualServerRaster::fixed_material_set_detail_blend_mode(RID p_material,MaterialBlendMode p_mode) {
+	VS_CHANGED;
+	rasterizer->fixed_material_set_detail_blend_mode(p_material,p_mode);
+}
+
+VS::MaterialBlendMode VisualServerRaster::fixed_material_get_detail_blend_mode(RID p_material) const {
+
+	return rasterizer->fixed_material_get_detail_blend_mode(p_material);
+}
+
+
+
+
+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);
+}
+
+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);
+}
+
+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);
+}
+
+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) {
+	VS_CHANGED;
+	rasterizer->fixed_material_set_uv_transform(p_material,p_transform);
+}
+
+Transform VisualServerRaster::fixed_material_get_uv_transform(RID p_material) const {
+
+	return rasterizer->fixed_material_get_uv_transform(p_material);
+}
+
+
+
+/* MESH API */	
+
+RID VisualServerRaster::mesh_create() {
+
+	return rasterizer->mesh_create();
+}
+
+void VisualServerRaster::mesh_set_morph_target_count(RID p_mesh,int 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 );
+
+	if (!E)
+		return;
+
+
+	Set<RID>::Element *I = E->get().front();
+
+	while(I) {
+
+		Instance *ins = instance_owner.get( I->get() );
+		ins->data.morph_values.resize(amount);
+		I = I->next();
+	}
+}
+
+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) {
+
+	rasterizer->mesh_set_morph_target_mode(p_mesh,p_mode);
+}
+
+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_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);
+	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 {
+
+	return rasterizer->mesh_get_surface_arrays(p_mesh,p_surface);
+}
+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);
+}
+
+
+
+
+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);
+}
+
+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{
+
+	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{
+
+
+	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{
+
+	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{
+
+	return rasterizer->mesh_surface_get_primitive_type(p_mesh,p_surface);
+}
+
+
+void VisualServerRaster::mesh_remove_surface(RID p_mesh,int p_surface){
+
+	rasterizer->mesh_remove_surface(p_mesh,p_surface);
+}
+
+int VisualServerRaster::mesh_get_surface_count(RID p_mesh) const{
+
+	return rasterizer->mesh_get_surface_count(p_mesh);
+
+}
+
+/* MULTIMESH */
+
+RID VisualServerRaster::multimesh_create() {
+
+	return rasterizer->multimesh_create();
+}
+
+void VisualServerRaster::multimesh_set_instance_count(RID p_multimesh,int p_count) {
+	VS_CHANGED;
+	rasterizer->multimesh_set_instance_count(p_multimesh,p_count);
+}
+
+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) {
+	VS_CHANGED;
+	rasterizer->multimesh_set_mesh(p_multimesh,p_mesh);
+
+}
+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);
+
+}
+
+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);
+
+}
+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);
+
+}
+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 {
+
+
+	return rasterizer->multimesh_get_aabb(p_multimesh);
+}
+
+Transform VisualServerRaster::multimesh_instance_get_transform(RID p_multimesh,int p_index) const {
+
+	return rasterizer->multimesh_instance_get_transform(p_multimesh,p_index);
+}
+Color VisualServerRaster::multimesh_instance_get_color(RID p_multimesh,int p_index) const {
+
+	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);
+
+}
+
+int VisualServerRaster::multimesh_get_visible_instances(RID p_multimesh) const {
+
+	return rasterizer->multimesh_get_visible_instances(p_multimesh);
+}
+
+
+
+
+/* PARTICLES API */
+
+RID VisualServerRaster::particles_create() {
+
+	return rasterizer->particles_create();
+}
+
+void VisualServerRaster::particles_set_amount(RID p_particles, int p_amount) {
+	VS_CHANGED;
+	rasterizer->particles_set_amount(p_particles,p_amount);	
+}
+
+int VisualServerRaster::particles_get_amount(RID p_particles) const {
+
+	return rasterizer->particles_get_amount(p_particles);
+}
+	
+void VisualServerRaster::particles_set_emitting(RID p_particles, bool p_emitting) {
+	VS_CHANGED;
+	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) {
+	VS_CHANGED;
+	rasterizer->particles_set_visibility_aabb(p_particles, p_visibility);
+}
+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) {
+	VS_CHANGED;
+	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) {
+	VS_CHANGED;
+	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) {
+
+	VS_CHANGED;
+	rasterizer->particles_set_emission_points(p_particles,p_points);
+}
+
+DVector<Vector3> VisualServerRaster::particles_get_emission_points(RID p_particles) const {
+
+	return rasterizer->particles_get_emission_points(p_particles);
+}
+
+void VisualServerRaster::particles_set_gravity_normal(RID p_particles, const Vector3& p_normal) {
+	VS_CHANGED;
+	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) {
+	VS_CHANGED;
+	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);
+}
+
+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);
+}
+float VisualServerRaster::particles_get_randomness(RID p_particles, ParticleVariable p_variable) const {
+
+	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);
+}
+int VisualServerRaster::particles_get_color_phases(RID p_particles) const {
+
+	return rasterizer->particles_get_color_phases(p_particles);
+}
+
+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);
+}
+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);
+}
+
+void VisualServerRaster::particles_set_attractors(RID p_particles, int p_attractors) {
+	VS_CHANGED;
+	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) {
+	VS_CHANGED;
+	rasterizer->particles_set_attractor_pos(p_particles,p_attractor,p_pos);
+}
+Vector3 VisualServerRaster::particles_get_attractor_pos(RID p_particles,int p_attractor) const {
+
+	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);
+}
+
+float VisualServerRaster::particles_get_attractor_strength(RID p_particles,int p_attractor) const {
+
+	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) {
+	VS_CHANGED;
+	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);
+}
+
+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);
+}
+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);
+
+}
+
+bool VisualServerRaster::particles_has_height_from_velocity(RID p_particles) const {
+
+	return rasterizer->particles_has_height_from_velocity(p_particles);
+}
+
+void VisualServerRaster::particles_set_use_local_coordinates(RID p_particles, bool p_enable) {
+
+	rasterizer->particles_set_use_local_coordinates(p_particles,p_enable);
+}
+
+bool VisualServerRaster::particles_is_using_local_coordinates(RID p_particles) const {
+
+	return rasterizer->particles_is_using_local_coordinates(p_particles);
+}
+
+
+/* Light API */
+
+RID VisualServerRaster::light_create(LightType p_type) {
+
+	return rasterizer->light_create(p_type);
+}
+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) {
+	VS_CHANGED;
+	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);
+	
+}
+
+
+void VisualServerRaster::light_set_shadow(RID p_light,bool p_enabled) {
+	VS_CHANGED;
+	rasterizer->light_set_shadow(p_light,p_enabled);	
+}
+
+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) {
+	VS_CHANGED;
+	rasterizer->light_set_volumetric(p_light,p_enabled);	
+}
+
+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) {
+	VS_CHANGED;
+	rasterizer->light_set_projector(p_light,p_texture);
+}
+
+RID VisualServerRaster::light_get_projector(RID p_light) const {
+
+	return rasterizer->light_get_projector(p_light);
+}
+
+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);
+	
+}
+
+float VisualServerRaster::light_get_param(RID p_light, LightParam p_var) const {
+	
+
+	return rasterizer->light_get_var(p_light,p_var);	
+}
+
+void VisualServerRaster::light_set_operator(RID p_light,LightOp p_op) {
+	VS_CHANGED;
+	rasterizer->light_set_operator(p_light,p_op);
+}
+
+VisualServerRaster::LightOp VisualServerRaster::light_get_operator(RID p_light) const {
+
+	return rasterizer->light_get_operator(p_light);
+}
+
+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);
+}
+
+VisualServerRaster::LightOmniShadowMode VisualServerRaster::light_omni_get_shadow_mode(RID p_light) const {
+
+	return rasterizer->light_omni_get_shadow_mode(p_light);
+}
+
+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);
+}
+
+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) {
+	VS_CHANGED;
+	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 {
+
+	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) {
+	VS_CHANGED;
+	rasterizer->skeleton_resize(p_skeleton,p_bones);
+}
+
+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) {
+	VS_CHANGED;
+	return rasterizer->skeleton_bone_set_transform(p_skeleton,p_bone,p_transform);
+
+}
+
+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 );
+
+}
+
+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;
+
+}
+
+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 );
+
+
+}
+
+
+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->bounds=Rect2();
+
+	for(int i=0;i<p_shape.size();i++) {
+
+		if (i==0)
+			portal->bounds.pos=p_shape[i];
+		else
+			portal->bounds.expand_to(p_shape[i]);
+	}
+
+	_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;
+
+}
+
+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;
+
+}
+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) {
+	VS_CHANGED;
+	Portal *portal = portal_owner.get(p_portal);
+	ERR_FAIL_COND(!portal);
+	portal->disable_color=p_color;
+
+}
+Color VisualServerRaster::portal_get_disabled_color(RID p_portal) const {
+
+	Portal *portal = portal_owner.get(p_portal);
+	ERR_FAIL_COND_V(!portal, Color());
+	return portal->disable_color;
+}
+
+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);
+}
+
+float VisualServerRaster::portal_get_connect_range(RID p_portal) const {
+
+	Portal *portal = portal_owner.get(p_portal);
+	ERR_FAIL_COND_V(!portal,0);
+	return portal->connect_range;
+}
+
+
+/* CAMERA API */
+
+RID VisualServerRaster::camera_create() {
+
+	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) {
+	VS_CHANGED;
+	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;
+	
+}
+
+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 );
+	ERR_FAIL_COND(!camera);
+	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) {
+	VS_CHANGED;
+	Camera *camera = camera_owner.get( p_camera );
+	ERR_FAIL_COND(!camera);
+	camera->transform=p_transform;
+	
+
+}
+
+void VisualServerRaster::camera_set_visible_layers(RID p_camera,uint32_t p_layers) {
+
+	VS_CHANGED;
+	Camera *camera = camera_owner.get( p_camera );
+	ERR_FAIL_COND(!camera);
+
+	camera->visible_layers=p_layers;
+
+}
+
+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);
+
+	return camera->visible_layers;
+}
+
+void VisualServerRaster::camera_set_environment(RID p_camera,RID p_env) {
+
+	Camera *camera = camera_owner.get( p_camera );
+	ERR_FAIL_COND(!camera);
+	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());
+	return camera->env;
+
+}
+
+void VisualServerRaster::camera_set_use_vertical_aspect(RID p_camera,bool p_enable) {
+
+	Camera *camera = camera_owner.get( p_camera );
+	ERR_FAIL_COND(!camera);
+	camera->vaspect=p_enable;
+
+}
+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);
+	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->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) {
+
+	VS_CHANGED;
+	Viewport *viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+
+	screen_viewports[p_viewport]=p_screen;
+}
+
+void VisualServerRaster::viewport_detach(RID p_viewport) {
+
+	VS_CHANGED;
+	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) {
+
+	VS_CHANGED;
+	Viewport *viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	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();
+		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_update_list.add(&viewport->update_list);
+	}
+
+}
+
+void VisualServerRaster::viewport_set_render_target_update_mode(RID p_viewport,RenderTargetUpdateMode p_mode){
+
+	VS_CHANGED;
+	Viewport *viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	if (viewport->update_list.in_list())
+		viewport_update_list.remove(&viewport->update_list);
+
+	viewport->render_target_update_mode=p_mode;
+
+	if (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{
+
+	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{
+
+	Viewport *viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND_V(!viewport,RID());
+
+	return viewport->render_target_texture;
+
+}
+
+void VisualServerRaster::viewport_queue_screen_capture(RID p_viewport) {
+
+	VS_CHANGED;
+	Viewport *viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+	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());
+
+	Image ret = viewport->capture;
+	viewport->capture=Image();
+	return ret;
+}
+
+void VisualServerRaster::viewport_set_rect(RID p_viewport,const ViewportRect& p_rect) {
+	VS_CHANGED;
+	Viewport *viewport=NULL;
+
+	viewport = viewport_owner.get( p_viewport );
+
+	ERR_FAIL_COND(!viewport);
+	
+	viewport->rect=p_rect;
+}
+
+
+VisualServer::ViewportRect VisualServerRaster::viewport_get_rect(RID p_viewport) const {
+
+	const Viewport *viewport=NULL;
+
+	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) {
+
+	VS_CHANGED;
+
+	Viewport *viewport=NULL;
+
+	viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	viewport->hide_scenario=p_hide;
+
+
+}
+
+void VisualServerRaster::viewport_set_hide_canvas(RID p_viewport,bool p_hide) {
+
+	VS_CHANGED;
+
+	Viewport *viewport=NULL;
+
+	viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	viewport->hide_canvas=p_hide;
+
+
+}
+
+void VisualServerRaster::viewport_attach_camera(RID p_viewport,RID p_camera) {
+	VS_CHANGED;
+
+	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;
+	} else {
+		viewport->camera=RID();
+	}
+
+}
+
+void VisualServerRaster::viewport_set_scenario(RID p_viewport,RID p_scenario) {
+
+	VS_CHANGED;
+
+	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;
+	} else {
+		viewport->scenario=RID();
+	}
+
+}
+
+RID VisualServerRaster::viewport_get_attached_camera(RID p_viewport) const {
+
+	const Viewport *viewport=NULL;
+
+	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) {
+	VS_CHANGED;
+	Viewport *viewport=NULL;
+
+	viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	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;
+
+	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) {
+
+	VS_CHANGED;
+	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);
+	if (!E) {
+		ERR_EXPLAIN("Viewport does not contain the canvas");
+		ERR_FAIL_COND(!E);
+	}
+
+	E->get().transform=p_transform;
+
+}
+
+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());
+
+	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());
+	}
+
+
+	return E->get().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 );
+	ERR_FAIL_COND(!viewport);
+
+	viewport->global_transform=p_transform;
+
+}
+
+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());
+	return viewport->global_transform;
+}
+
+void VisualServerRaster::viewport_remove_canvas(RID p_viewport,RID p_canvas) {
+
+	VS_CHANGED;
+	Viewport *viewport=NULL;
+
+	viewport = viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	Canvas *canvas = canvas_owner.get( p_canvas );	
+	ERR_FAIL_COND(!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) {
+
+	VS_CHANGED;
+	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);
+	if (!E) {
+		ERR_EXPLAIN("Viewport does not contain the canvas");
+		ERR_FAIL_COND(!E);
+	}
+
+	E->get().layer=p_layer;
+	
+}
+
+void VisualServerRaster::viewport_set_transparent_background(RID p_viewport,bool p_enabled) {
+
+	VS_CHANGED;
+	Viewport *viewport=viewport_owner.get( p_viewport );
+	ERR_FAIL_COND(!viewport);
+
+	viewport->transparent_bg=p_enabled;
+}
+
+bool VisualServerRaster::viewport_has_transparent_background(RID p_viewport) const {
+
+	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 {
+	
+	const Viewport *viewport=NULL;
+
+	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){
+
+	rasterizer->environment_set_background(p_env,p_bg);
+}
+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){
+
+
+	rasterizer->environment_set_background_param(p_env,p_param,p_value);
+}
+Variant VisualServerRaster::environment_get_background_param(RID p_env,EnvironmentBGParam p_param) const{
+
+	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){
+
+	rasterizer->environment_set_enable_fx(p_env,p_effect,p_enabled);
+}
+bool VisualServerRaster::environment_is_fx_enabled(RID p_env,EnvironmentFx p_effect) const{
+
+	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){
+
+	rasterizer->environment_fx_set_param(p_env,p_param,p_value);
+}
+Variant VisualServerRaster::environment_fx_get_param(RID p_env,EnvironmentFxParam p_param) const {
+
+	return environment_fx_get_param(p_env,p_param);
+}
+
+
+
+/* SCENARIO API */
+
+void VisualServerRaster::_dependency_queue_update(RID p_rid,bool p_update_aabb) {
+
+	Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
+	
+	if (!E)
+		return;
+		
+		
+	Set<RID>::Element *I = E->get().front();
+	
+	while(I) {
+		
+		Instance *ins = instance_owner.get( I->get() );
+		_instance_queue_update( ins , p_update_aabb );
+	
+		I = I->next();
+	}
+	
+}
+
+void VisualServerRaster::_instance_queue_update(Instance *p_instance,bool p_update_aabb) {
+
+	if (p_update_aabb)
+		p_instance->update_aabb=true;
+		
+	if (p_instance->update)
+		return;
+	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);
+
+	return scenario_rid;
+}
+
+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;
+}
+
+void VisualServerRaster::scenario_set_environment(RID p_scenario, RID p_environment) {
+
+	VS_CHANGED;
+
+	Scenario *scenario = scenario_owner.get(p_scenario);
+	ERR_FAIL_COND(!scenario);
+	scenario->environment=p_environment;
+
+}
+
+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());
+	return scenario->environment;
+
+}
+
+
+/* INSTANCING API */
+
+
+RID VisualServerRaster::instance_create() {
+
+	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;
+
+	return instance_rid;
+}
+
+void VisualServerRaster::instance_set_base(RID p_instance, RID p_base) {
+
+	VS_CHANGED;
+	Instance *instance = instance_owner.get( p_instance );
+	ERR_FAIL_COND( !instance );
+
+	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 );
+
+		if (E) {
+			// wtf, no E?
+			E->get().erase( instance->self );
+
+		} else {
+
+			ERR_PRINT("no base E? Bug?");
+		}
+
+		if ( instance->room ) {
+
+			instance_set_room(p_instance,RID());
+			/*
+			if((1<<instance->base_type)&INSTANCE_GEOMETRY_MASK)
+				instance->room->room_info->owned_geometry_instances.erase(instance->RE);
+			else if (instance->base_type==INSTANCE_PORTAL) {
+				print_line("freeing portal, is it there? "+itos(instance->room->room_info->owned_portal_instances.(instance->RE)));
+				instance->room->room_info->owned_portal_instances.erase(instance->RE);
+			} else if (instance->base_type==INSTANCE_ROOM)
+				instance->room->room_info->owned_room_instances.erase(instance->RE);
+			else if (instance->base_type==INSTANCE_LIGHT)
+				instance->room->room_info->owned_light_instances.erase(instance->RE);
+
+			instance->RE=NULL;*/
+		}
+
+
+
+
+
+		if (instance->light_info) {
+
+			if (instance->scenario && 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;
+		}
+
+
+		if (instance->portal_info) {
+
+			_portal_disconnect(instance,true);
+			memdelete(instance->portal_info);
+			instance->portal_info=NULL;
+
+		}
+
+		if (instance->scenario && instance->octree_id) {
+			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()) {
+
+				Instance *owned = E->get();
+				owned->room=NULL;
+				owned->RE=NULL;
+			}
+			for(List<Instance*>::Element *E=instance->room_info->owned_portal_instances.front();E;E=E->next()) {
+
+				_portal_disconnect(E->get(),true);
+				Instance *owned = E->get();
+				owned->room=NULL;
+				owned->RE=NULL;
+			}
+
+			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;
+			}
+
+			if (instance->room_info->disconnected_child_portals.size()) {
+				ERR_PRINT("BUG: Disconnected portals remain!");
+			}
+			memdelete(instance->room_info);
+			instance->room_info=NULL;
+
+		}
+
+		if (instance->particles_info) {
+
+			rasterizer->free( instance->particles_info->instance );
+			memdelete(instance->particles_info);
+			instance->particles_info=NULL;
+
+		}
+
+		instance->data.morph_values.clear();
+
+	}
+
+
+	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));
+		} else if (rasterizer->is_multimesh(p_base)) {
+			instance->base_type=INSTANCE_MULTIMESH;
+		} 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 );
+		} else if (rasterizer->is_light(p_base)) {
+
+			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) {
+
+				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);
+		} else if (portal_owner.owns(p_base)) {
+
+			instance->base_type=INSTANCE_PORTAL;
+			instance->portal_info = memnew(Instance::PortalInfo);
+			instance->portal_info->portal=portal_owner.get(p_base);
+		} else {
+			ERR_EXPLAIN("Invalid base RID for instance!")
+			ERR_FAIL();
+		}
+
+		instance_dependency_map[ p_base ].insert( instance->self );
+
+		instance->base_rid=p_base;
+
+		if (instance->scenario)
+			_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() );
+	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 );
+
+	if (instance->scenario) {
+
+		Map< RID, Set<RID> >::Element *E = instance_dependency_map.find( instance->scenario->self );
+
+		if (E) {
+			// wtf, no E?
+			E->get().erase( instance->self );
+
+		} else {
+
+			ERR_PRINT("no scenario E? Bug?");
+		}
+
+		if (instance->light_info) {
+
+			if (instance->light_info->D)
+				instance->scenario->directional_lights.erase( instance->light_info->D );
+		}
+
+		if (instance->portal_info) {
+
+			_portal_disconnect(instance,true);
+		}
+
+		if (instance->octree_id) {
+			instance->scenario->octree.erase( instance->octree_id );
+			instance->octree_id=0;
+		}
+
+		instance->scenario=NULL;
+	}
+
+
+	if (p_scenario.is_valid()) {
+		Scenario *scenario = scenario_owner.get( p_scenario );
+		ERR_FAIL_COND(!scenario);
+
+		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) {
+
+			instance->light_info->D = instance->scenario->directional_lights.push_back(instance->self);
+		}
+
+		_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() );
+	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;
+
+}
+
+uint32_t VisualServerRaster::instance_get_layer_mask(RID p_instance) const{
+
+	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() );
+	return instance->aabb;
+
+}
+
+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->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 );
+	return instance->object_ID;
+
+}
+
+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->data.skeleton=p_skeleton;
+
+}
+
+RID VisualServerRaster::instance_get_skeleton(RID p_instance) const {
+
+	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) {
+
+	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;
+}
+
+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 );
+	return instance->data.morph_values[p_shape];
+}
+
+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 );
+	
+	if (p_transform==instance->data.transform) // must improve somehow
+		return;
+		
+	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() );
+	
+	return instance->data.transform;
+
+}
+
+void VisualServerRaster::instance_set_exterior( RID p_instance, bool p_enabled ) {
+	VS_CHANGED;
+	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)
+		return;
+	instance->exterior=p_enabled;
+	_instance_queue_update( instance );
+
+
+}
+
+bool VisualServerRaster::instance_is_exterior( RID p_instance) const {
+
+	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 ) {
+	VS_CHANGED;
+
+	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 ) {
+
+			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 );
+			}
+
+
+		} 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()) {
+				_portal_disconnect(E->get());
+				_instance_queue_update( E->get(),false );
+			}
+
+		} else if ( instance->base_type==INSTANCE_PORTAL ) {
+
+			_portal_disconnect(instance,true);
+			bool ss = instance->room->room_info->owned_portal_instances.erase(instance->RE);
+
+		} 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;
+
+
+	} 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 );
+		}
+
+	}
+
+	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 );
+
+
+	if (instance->base_type==INSTANCE_ROOM) {
+
+		//perform cycle test
+
+		Instance *parent = instance;
+
+		while(parent) {
+
+			ERR_EXPLAIN("Cycle in room assignment");
+			ERR_FAIL_COND( parent == room );
+			parent=parent->room;
+		}				
+	}
+
+	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 ) {
+
+		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 );
+
+
+	} 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 ) {
+
+		instance->RE = room->room_info->owned_light_instances.push_back(instance);
+	} else {
+
+		ERR_FAIL();
+
+	}
+
+	instance->room=room;
+}
+
+RID VisualServerRaster::instance_get_room( RID p_instance ) const  {
+
+	Instance *instance = instance_owner.get( p_instance );
+	ERR_FAIL_COND_V( !instance, RID() );
+
+	if (instance->room)
+		return instance->room->self;
+	else
+		return RID();
+}
+
+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->extra_margin=p_margin;
+}
+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 );
+
+	return instance->extra_margin;
+}
+
+
+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);	
+	
+	const_cast<VisualServerRaster*>(this)->_update_instances(); // check dirty instances before culling
+	
+	int culled=0;
+	Instance *cull[1024];
+	culled=scenario->octree.cull_AABB(p_aabb,cull,1024);
+	
+	for (int i=0;i<culled;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> 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
+	
+	int culled=0;
+	Instance *cull[1024];	
+	culled=scenario->octree.cull_segment(p_from,p_to*10000,cull,1024);
+
+
+	for (int i=0;i<culled;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> 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
+	
+	int culled=0;
+	Instance *cull[1024];	
+	
+
+	culled=scenario->octree.cull_convex(p_convex,cull,1024);
+	
+	for (int i=0;i<culled;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) {
+
+	Instance *instance = instance_owner.get( p_instance );
+	ERR_FAIL_COND( !instance );
+//	ERR_FAIL_COND( ! ( (1<<instance->base_type) & INSTANCE_GEOMETRY_MASK) );
+
+	switch(p_flags) {
+
+		case INSTANCE_FLAG_VISIBLE: {
+
+			instance->visible=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_BILLBOARD: {
+
+			instance->data.billboard=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
+
+			instance->data.billboard_y=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_CAST_SHADOW: {
+			instance->cast_shadows=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_RECEIVE_SHADOWS: {
+
+			instance->receive_shadows=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_DEPH_SCALE: {
+
+			instance->data.depth_scale=p_enabled;
+
+		} break;
+		case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
+
+			instance->visible_in_all_rooms=p_enabled;
+
+		} break;
+
+	}
+
+}
+
+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 );
+
+	switch(p_flags) {
+
+		case INSTANCE_FLAG_VISIBLE: {
+
+			return instance->visible;
+
+		} break;
+		case INSTANCE_FLAG_BILLBOARD: {
+
+			return instance->data.billboard;
+
+		} break;
+		case INSTANCE_FLAG_BILLBOARD_FIX_Y: {
+
+			return instance->data.billboard_y;
+
+		} break;
+		case INSTANCE_FLAG_CAST_SHADOW: {
+			return instance->cast_shadows;
+
+		} break;
+		case INSTANCE_FLAG_RECEIVE_SHADOWS: {
+
+			return instance->receive_shadows;
+
+		} break;
+		case INSTANCE_FLAG_DEPH_SCALE: {
+
+			return instance->data.depth_scale;
+
+		} break;
+		case INSTANCE_FLAG_VISIBLE_IN_ALL_ROOMS: {
+
+			return instance->visible_in_all_rooms;
+
+		} break;
+
+	}
+
+	return false;
+}
+
+
+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;
+
+}
+
+RID VisualServerRaster::instance_geometry_get_material_override(RID p_instance) const{
+
+	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){
+
+	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;
+
+}
+
+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 );
+
+	return instance->draw_range_begin;
+
+
+}
+
+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 );
+
+	return instance->draw_range_end;
+
+
+}
+
+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 );
+		
+	}
+
+	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 );
+	}
+		
+
+	if (p_instance->base_type&INSTANCE_GEOMETRY_MASK) {
+
+		//make sure lights are updated
+		InstanceSet::Element *E=p_instance->lights.front();
+		while(E) {
+
+			E->get()->version++;
+			E=E->next();
+		}
+
+	}
+
+	if (p_instance->base_type == INSTANCE_ROOM) {
+
+		p_instance->room_info->affine_inverse=p_instance->data.transform.affine_inverse();
+	}
+
+	p_instance->data.mirror = p_instance->data.transform.basis.determinant() < 0.0;
+
+	AABB new_aabb;
+
+	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());
+
+		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++) {
+
+			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;
+			else
+				portal_aabb.expand_to(point);
+		}
+		
+		portal_aabb.grow_by(p_instance->portal_info->portal->connect_range);
+
+		new_aabb = portal_aabb;
+
+	} else {
+
+		new_aabb = p_instance->data.transform.xform(p_instance->aabb);
+	}
+
+
+	for(InstanceSet::Element *E=p_instance->lights.front();E;E=E->next()) {
+		Instance *light = E->get();
+		light->version++;
+	}
+
+
+	p_instance->transformed_aabb=new_aabb;
+
+	if (!p_instance->scenario) {
+
+
+		return;
+	}
+
+
+
+	if (p_instance->octree_id==0) {
+
+		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=INSTANCE_GEOMETRY_MASK;
+			pairable=true;
+		}
+
+		if (p_instance->base_type == INSTANCE_PORTAL) {
+
+			pairable_mask=(1<<INSTANCE_PORTAL);
+			pairable=true;
+		}
+
+		if (!p_instance->room && (1<<p_instance->base_type)&INSTANCE_GEOMETRY_MASK) {
+
+			base_type|=INSTANCE_ROOMLESS_MASK;
+		}
+
+		if (p_instance->base_type == INSTANCE_ROOM) {
+
+			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);
+
+	} else {
+
+	//	if (new_aabb==p_instance->data.transformed_aabb)
+	//		return;
+
+		p_instance->scenario->octree.move(p_instance->octree_id,new_aabb);
+	}
+
+	if (p_instance->base_type==INSTANCE_PORTAL) {
+				
+		_portal_attempt_connect(p_instance);
+	}
+
+	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())
+			_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());
+			
+	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);
+			
+		} break;
+		case VisualServer::INSTANCE_MULTIMESH: {
+
+			new_aabb = rasterizer->multimesh_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: {
+			
+			new_aabb = rasterizer->light_get_aabb(p_instance->base_rid);
+						
+		} break;
+		case VisualServer::INSTANCE_ROOM: {
+		
+			Room *room = room_owner.get( p_instance->base_rid );
+			ERR_FAIL_COND(!room);
+			new_aabb=room->bounds.get_aabb();
+			
+		} break;
+		case VisualServer::INSTANCE_PORTAL: {
+		
+			Portal *portal = portal_owner.get( p_instance->base_rid );
+			ERR_FAIL_COND(!portal);			
+			for (int i=0;i<portal->shape.size();i++) {
+			
+				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
+				} else {
+				
+					new_aabb.expand_to(point);
+				}
+			}
+
+		} break;			
+		default: {}
+	}
+
+	if (p_instance->extra_margin)
+		new_aabb.grow_by(p_instance->extra_margin);
+	
+	p_instance->aabb=new_aabb;
+			
+}
+
+void VisualServerRaster::_update_instances() {
+
+	while(instance_update_list) {
+	
+		Instance *instance=instance_update_list;
+
+		instance_update_list=instance_update_list->update_next;
+		
+		if (instance->update_aabb)
+			_update_instance_aabb(instance);
+			
+		_update_instance(instance);
+		
+		instance->update=false;
+		instance->update_aabb=false;
+		instance->update_next=0;
+	}
+}
+
+/****** CANVAS *********/
+RID VisualServerRaster::canvas_create() {
+
+	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) {
+
+	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;
+
+}
+
+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());
+
+	int idx = canvas->find_item(canvas_item);
+	ERR_FAIL_COND_V(idx==-1,Point2());
+	return canvas->child_items[idx].mirror;
+}
+
+
+RID VisualServerRaster::canvas_item_create() {
+	
+	CanvasItem *canvas_item = memnew( CanvasItem );
+	ERR_FAIL_COND_V(!canvas_item,RID());
+		
+	return canvas_item_owner.make_rid( canvas_item );
+}
+
+void VisualServerRaster::canvas_item_set_parent(RID p_item,RID p_parent) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	if (canvas_item->parent.is_valid()) {
+
+		if (canvas_owner.owns(canvas_item->parent)) {
+
+			Canvas *canvas = canvas_owner.get(canvas_item->parent);
+			canvas->erase_item(canvas_item);
+		} else if (canvas_item_owner.owns(canvas_item->parent)) {
+
+			CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
+			item_owner->child_items.erase(canvas_item);
+		}
+
+		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;
+			canvas->child_items.push_back(ci);
+		} else if (canvas_item_owner.owns(p_parent)) {
+
+			CanvasItem *item_owner = canvas_item_owner.get(p_parent);
+			item_owner->child_items.push_back(canvas_item);
+
+		} else {
+
+			ERR_EXPLAIN("Invalid parent");
+			ERR_FAIL();
+		}
+
+
+	}
+
+	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());
+
+	return canvas_item->parent;
+}
+
+void VisualServerRaster::canvas_item_set_visible(RID p_item,bool p_visible) {
+
+	VS_CHANGED;
+
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	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());
+
+	return canvas_item->visible;
+
+}
+
+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 );
+	if (!canvas_item) {
+		printf("!canvas_item\n");
+	};
+	ERR_FAIL_COND(!canvas_item);
+
+	if (canvas_item->blend_mode==p_blend)
+		return;
+	VS_CHANGED;
+
+	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 );
+	ERR_FAIL_COND(!canvas_item);
+
+	VS_CHANGED;
+
+	canvas_item->viewport=p_viewport;
+
+}
+
+
+/*
+void VisualServerRaster::canvas_item_set_rect(RID p_item, const Rect2& p_rect) {
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	
+	canvas_item->rect=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 );
+	ERR_FAIL_COND(!canvas_item);
+	
+	canvas_item->clip=p_clip;
+}
+
+const Rect2& VisualServerRaster::CanvasItem::get_rect() const {
+
+	if (custom_rect || !rect_dirty)
+		return rect;
+
+	//must update rect
+	int s=commands.size();
+	if (s==0) {
+
+		rect=Rect2();
+		rect_dirty=false;
+		return rect;
+	}
+
+	Matrix32 xf;
+	bool found_xform=false;
+	bool first=true;
+
+	const CanvasItem::Command * const *cmd = &commands[0];
+
+
+	for (int i=0;i<s;i++) {
+
+		const  CanvasItem::Command *c=cmd[i];
+		Rect2 r;
+
+		switch(c->type) {
+			case CanvasItem::Command::TYPE_LINE: {
+
+				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;
+
+			} break;
+			case CanvasItem::Command::TYPE_STYLE: {
+
+				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++) {
+
+					r.expand_to(primitive->points[i]);
+
+				}
+			} break;
+			case CanvasItem::Command::TYPE_POLYGON: {
+
+				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++) {
+
+					r.expand_to(pp[i]);
+
+				}
+			} break;
+
+			case CanvasItem::Command::TYPE_POLYGON_PTR: {
+
+				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<polygon->count; i++) {
+
+						r.expand_to(polygon->points[polygon->indices[i]]);
+					};
+				} else {
+					r.pos=polygon->points[0];
+					for (int i=1; i<polygon->count; i++) {
+
+						r.expand_to(polygon->points[i]);
+					};
+				};
+			} 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);
+			} break;
+			case CanvasItem::Command::TYPE_TRANSFORM: {
+
+				const CanvasItem::CommandTransform* transform = static_cast<const CanvasItem::CommandTransform*>(c);
+				xf=transform->xform;
+				found_xform=true;
+				continue;
+			} break;
+			case CanvasItem::Command::TYPE_BLEND_MODE: {
+
+			} break;
+			case CanvasItem::Command::TYPE_CLIP_IGNORE: {
+
+			} break;
+		}
+
+		if (found_xform) {
+			r = xf.xform(r);
+			found_xform=false;
+		}
+
+
+		if (first) {
+			rect=r;
+			first=false;
+		} else
+			rect=rect.merge(r);
+	}
+
+	rect_dirty=false;
+	return rect;
+}
+
+void VisualServerRaster::canvas_item_set_transform(RID p_item, const Matrix32& p_transform) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	canvas_item->xform=p_transform;
+
+}
+
+
+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 );
+	ERR_FAIL_COND(!canvas_item);
+
+	canvas_item->custom_rect=p_custom_rect;
+	if (p_custom_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 );
+	ERR_FAIL_COND(!canvas_item);
+	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);
+	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 );
+	ERR_FAIL_COND(!canvas_item);
+	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);
+	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 );
+	ERR_FAIL_COND(!canvas_item);
+	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);
+	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) {
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	
+	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;
+
+	
+	canvas_item->commands.push_back(line);	
+}
+
+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 );
+	ERR_FAIL_COND(!canvas_item);
+	
+	CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
+	ERR_FAIL_COND(!rect);
+	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) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	CanvasItem::CommandCircle * circle = memnew( CanvasItem::CommandCircle );
+	ERR_FAIL_COND(!circle);
+	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) {
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	
+	CanvasItem::CommandRect * rect = memnew( CanvasItem::CommandRect );
+	ERR_FAIL_COND(!rect);
+	rect->modulate=p_modulate;
+	rect->rect=p_rect;
+	rect->flags=0;
+	if (p_tile)
+		rect->flags|=Rasterizer::CANVAS_RECT_TILE;
+
+	if (p_rect.size.x<0) {
+
+		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
+		rect->rect.size.x = -rect->rect.size.x;
+	}
+	if (p_rect.size.y<0) {
+
+		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
+		rect->rect.size.y = -rect->rect.size.y;
+	}
+	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)  {
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	
+	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;
+
+	if (p_rect.size.x<0) {
+
+		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_H;
+		rect->rect.size.x = -rect->rect.size.x;
+	}
+	if (p_rect.size.y<0) {
+
+		rect->flags|=Rasterizer::CANVAS_RECT_FLIP_V;
+		rect->rect.size.y = -rect->rect.size.y;
+	}
+
+	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, 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 );
+	ERR_FAIL_COND(!canvas_item);
+	
+	CanvasItem::CommandStyle * style = memnew( CanvasItem::CommandStyle );
+	ERR_FAIL_COND(!style);
+	style->texture=p_texture;
+	style->rect=p_rect;
+	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) {
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	
+	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;
+
+	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) {
+
+	VS_CHANGED;
+	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()));
+#endif
+	Vector<int> indices = Geometry::triangulate_polygon(p_points);
+
+	if (indices.empty()) {
+
+		ERR_EXPLAIN("Bad Polygon!");
+		ERR_FAIL_V();
+	}
+
+	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;
+
+	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) {
+
+	VS_CHANGED;
+	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 );
+	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->count = p_count * 3;
+	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) {
+
+	VS_CHANGED;
+	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);
+	ERR_FAIL_COND(!p_uvs.empty() && p_uvs.size()!=ps);
+
+	Vector<int> indices = p_indices;
+
+	int count = p_count * 3;
+
+	if (indices.empty()) {
+
+		ERR_FAIL_COND( ps % 3 != 0 );
+		if (p_count == -1)
+			count = ps;
+	} else {
+
+		ERR_FAIL_COND( indices.size() % 3 != 0 );
+		if (p_count == -1)
+			count = indices.size();
+	}
+
+	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 = count;
+	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) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	CanvasItem::CommandTransform * tr = memnew( CanvasItem::CommandTransform );
+	ERR_FAIL_COND(!tr);
+	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 );
+	ERR_FAIL_COND(!canvas_item);
+
+	CanvasItem::CommandBlendMode * bm = memnew( CanvasItem::CommandBlendMode );
+	ERR_FAIL_COND(!bm);
+	bm->blend_mode = p_blend;
+
+	canvas_item->commands.push_back(bm);
+};
+
+void VisualServerRaster::canvas_item_add_clip_ignore(RID p_item, bool p_ignore) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+
+	CanvasItem::CommandClipIgnore * ci = memnew( CanvasItem::CommandClipIgnore);
+	ERR_FAIL_COND(!ci);
+	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 );
+	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 );
+	ERR_FAIL_COND(!canvas_item);
+
+	if (canvas_item->parent.is_valid()) {
+
+		if (canvas_owner.owns(canvas_item->parent)) {
+
+			Canvas *canvas = canvas_owner.get(canvas_item->parent);
+			int idx = canvas->find_item(canvas_item);
+			ERR_FAIL_COND(idx<0);
+			Canvas::ChildItem ci = canvas->child_items[idx];
+			canvas->child_items.remove(idx);
+			canvas->child_items.push_back(ci);
+
+		} else if (canvas_item_owner.owns(canvas_item->parent)) {
+
+			CanvasItem *item_owner = canvas_item_owner.get(canvas_item->parent);
+			int idx = item_owner->child_items.find(canvas_item);
+			ERR_FAIL_COND(idx<0);
+			item_owner->child_items.remove(idx);
+			item_owner->child_items.push_back(canvas_item);
+
+		}
+	}
+
+}
+
+/******** CANVAS *********/
+
+
+void VisualServerRaster::cursor_set_rotation(float p_rotation, int p_cursor) {
+	VS_CHANGED;
+	ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
+
+	cursors[p_cursor].rot = p_rotation;
+};
+
+void VisualServerRaster::cursor_set_texture(RID p_texture, const Point2 &p_center_offset, int p_cursor) {
+	VS_CHANGED;
+	ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
+
+	cursors[p_cursor].texture = p_texture;
+	cursors[p_cursor].center = p_center_offset;
+};
+
+void VisualServerRaster::cursor_set_visible(bool p_visible, int p_cursor) {
+	VS_CHANGED;
+	ERR_FAIL_INDEX(p_cursor, MAX_CURSORS);
+
+	cursors[p_cursor].visible = p_visible;
+};
+
+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)
+		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;
+}
+
+
+void VisualServerRaster::_free_attached_instances(RID p_rid,bool p_free_scenario) {
+
+	Map< RID, Set<RID> >::Element * E = instance_dependency_map.find( p_rid );
+	
+	if (E) {
+		// has instances
+		while( E->get().size() ) {
+			// erase all attached instances
+			if (p_free_scenario)
+				instance_set_scenario( E->get().front()->get(), RID() );
+			else
+				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);
+}
+
+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) {
+
+	//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) {
+
+	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 {
+
+	//rasterizer->custom_shade_model_get_param_info(p_model,p_info);
+}
+
+void VisualServerRaster::free( RID p_rid ) {
+
+	VS_CHANGED;
+
+	if (rasterizer->is_texture(p_rid) || rasterizer->is_material(p_rid) || rasterizer->is_skeleton(p_rid) || rasterizer->is_shader(p_rid)) {
+	
+		rasterizer->free(p_rid);
+	
+	} else if (rasterizer->is_mesh(p_rid) || rasterizer->is_multimesh(p_rid) || rasterizer->is_light(p_rid) || rasterizer->is_particles(p_rid) ) {
+		//delete the resource
+	
+		_free_attached_instances(p_rid);
+		rasterizer->free(p_rid);
+	} else if (room_owner.owns(p_rid)) {
+
+		_free_attached_instances(p_rid);
+		Room *room = room_owner.get(p_rid);		
+		ERR_FAIL_COND(!room);		
+		room_owner.free(p_rid);
+		memdelete(room);
+
+
+	} else if (portal_owner.owns(p_rid)) {
+
+		_free_attached_instances(p_rid);
+
+		Portal *portal = portal_owner.get(p_rid);
+		ERR_FAIL_COND(!portal);
+		portal_owner.free(p_rid);
+		memdelete(portal);
+
+	} else if (camera_owner.owns(p_rid)) {
+		// delete te camera
+		
+		Camera *camera = camera_owner.get(p_rid);
+		ERR_FAIL_COND(!camera);
+		
+		camera_owner.free( p_rid );
+		memdelete(camera);
+		
+	} else if (viewport_owner.owns(p_rid)) {
+		// delete the viewport
+		
+		Viewport *viewport = viewport_owner.get( p_rid );
+		ERR_FAIL_COND(!viewport);
+
+//		Viewport *parent=NULL;
+
+		rasterizer->free(viewport->viewport_data);
+		if (viewport->render_target.is_valid()) {
+
+			rasterizer->free(viewport->render_target);
+		}
+
+		if (viewport->update_list.in_list())
+			viewport_update_list.remove(&viewport->update_list);
+		if (screen_viewports.has(p_rid))
+			screen_viewports.erase(p_rid);
+
+		while(viewport->canvas_map.size()) {
+
+			Canvas *c = viewport->canvas_map.front()->get().canvas;
+			c->viewports.erase(p_rid);
+
+			viewport->canvas_map.erase(viewport->canvas_map.front());
+		}
+
+		
+		viewport_owner.free(p_rid);		
+		memdelete(viewport);
+		
+	} else if (instance_owner.owns(p_rid)) {
+		// delete the instance
+	
+		_update_instances(); // be sure
+		
+		Instance *instance = instance_owner.get(p_rid);
+		ERR_FAIL_COND(!instance);
+
+		instance_set_room(p_rid,RID());
+		instance_set_scenario(p_rid,RID());
+		instance_set_base(p_rid,RID());
+			
+		instance_owner.free(p_rid);
+		memdelete(instance);
+		
+	} else if (canvas_owner.owns(p_rid)) {
+	
+		Canvas *canvas = canvas_owner.get(p_rid);
+		ERR_FAIL_COND(!canvas);
+
+		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);
+			ERR_FAIL_COND(!E);
+			vp->canvas_map.erase(p_rid);
+
+			canvas->viewports.erase( canvas->viewports.front() );
+		}
+
+		for (int i=0;i<canvas->child_items.size();i++) {
+
+			canvas->child_items[i].item->parent=RID();
+		}
+		
+		canvas_owner.free( p_rid );
+		
+		memdelete( canvas );
+		
+	} else if (canvas_item_owner.owns(p_rid)) {
+		
+		CanvasItem *canvas_item = canvas_item_owner.get(p_rid);
+		ERR_FAIL_COND(!canvas_item);
+
+		if (canvas_item->parent.is_valid()) {
+
+			if (canvas_owner.owns(canvas_item->parent)) {
+
+				Canvas *canvas = canvas_owner.get(canvas_item->parent);
+				canvas->erase_item(canvas_item);
+			} else if (canvas_item_owner.owns(canvas_item->parent)) {
+
+				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++) {
+
+			canvas_item->child_items[i]->parent=RID();
+		}
+
+		canvas_item_owner.free( p_rid );
+		
+		memdelete( canvas_item );
+	} else if (scenario_owner.owns(p_rid)) {
+		
+		Scenario *scenario=scenario_owner.get(p_rid);
+		ERR_FAIL_COND(!scenario);
+		
+		_update_instances(); // be sure
+		_free_attached_instances(p_rid,true);
+		
+		//rasterizer->free( scenario->environment );
+		scenario_owner.free(p_rid);
+		memdelete(scenario);
+		
+	} else {
+		
+		ERR_FAIL();
+	}
+	
+}
+
+
+
+void VisualServerRaster::_instance_draw(Instance *p_instance) {
+
+	if (p_instance->light_cache_dirty) {
+		int l=0;
+		//add positional lights
+		InstanceSet::Element *LE=p_instance->lights.front();
+		p_instance->data.light_instances.resize(p_instance->lights.size());
+		while(LE) {
+
+			p_instance->data.light_instances[l++]=LE->get()->light_info->instance;
+			LE=LE->next();
+		}
+		p_instance->light_cache_dirty=false;
+	}
+
+
+	switch(p_instance->base_type) {
+	
+		case INSTANCE_MESH: {
+			const float *morphs = NULL;
+			if (!p_instance->data.morph_values.empty()) {
+				morphs=&p_instance->data.morph_values[0];
+			}
+
+			rasterizer->add_mesh(p_instance->base_rid, &p_instance->data);
+		} break;		
+		case INSTANCE_MULTIMESH: {
+			rasterizer->add_multimesh(p_instance->base_rid, &p_instance->data);
+		} break;
+		case INSTANCE_PARTICLES: {
+			rasterizer->add_particles(p_instance->particles_info->instance, &p_instance->data);
+		} break;
+		default: {};
+	}
+}
+
+
+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) {
+
+		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);
+		} 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
+			);
+
+		} break;
+	}
+
+	//obtain the frustum endpoints
+
+	Vector<Vector3> endpoints;
+	endpoints.resize(8);
+	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<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();
+
+	float x_min,x_max;
+	float y_min,y_max;
+	float z_min,z_max;
+
+	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]);
+
+		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
+
+	Vector<Plane> light_frustum_planes;
+	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 );
+	//top/bottom
+	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
+
+	//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) {
+
+	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 cull_min=p_cull_range.min;
+	//float cull_max=p_cull_range.max;
+
+	
+	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++) {
+		float idm = i / (float)splits;
+		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;
+	
+	for (int i=0;i<splits;i++) {
+	
+		// setup a camera matrix for that range!
+		CameraMatrix camera_matrix;
+		
+		switch(p_camera->type) {
+				
+			case Camera::ORTHOGONAL: {
+			
+				camera_matrix.set_orthogonal(
+					p_camera->size,
+					viewport_rect.width / (float)viewport_rect.height,
+					distances[i],
+					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],
+					distances[i+1],
+					p_camera->vaspect
+
+				);
+					
+			} break;		
+		}	
+		
+		//obtain the frustum endpoints
+		
+		Vector3 endpoints[8]; // frustum plane 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();
+		//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;
+
+
+		//used for culling
+		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]);
+			
+			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++) {
+
+				center+=endpoints[j];
+			}
+			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;
+
+			for(int j=0;j<8;j++) {
+
+				float d = center.distance_to(endpoints[j]);
+				if (d>radius)
+					radius=d;
+			}
+
+
+			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;
+
+			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
+		
+		Vector<Plane> light_frustum_planes;
+		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 );
+		//top/bottom
+		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		
+							
+		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++) {
+		
+			float min,max;
+			Instance *ins=instance_shadow_cull_result[j];
+			if (!ins->visible || !ins->cast_shadows)
+				continue;
+			ins->transformed_aabb.project_range_in_plane(Plane(z_vec,0),min,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;
+
+
+			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;
+
+			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 );
+		
+		for (int j=0;j<caster_cull_count;j++) {
+		
+			Instance *instance = instance_shadow_cull_result[j];
+			if (!instance->visible || !instance->cast_shadows)
+				continue;
+			_instance_draw(instance);
+		}
+		
+		rasterizer->end_shadow_map();
+		
+	
+	}
+	
+	
+}
+
+
+CameraMatrix _lispm_look( const Vector3 pos, const Vector3 dir, const Vector3 up) {
+
+	Vector3 dirN;
+	Vector3 upN;
+	Vector3 lftN;
+
+	lftN=dir.cross(up);
+	lftN.normalize();
+
+	upN=lftN.cross(dir);
+	upN.normalize();
+	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;
+
+	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[10] = -dirN[2];
+	output[11] = 0.0;
+
+	output[12] = -lftN.dot(pos);
+	output[13] = -upN.dot(pos);
+	output[14] = dirN.dot(pos);
+	output[15] = 1.0;
+
+	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) {
+
+	Vector3 light_vec = -p_light->data.transform.basis.get_axis(2);
+	Vector3 view_vec = -p_camera->transform.basis.get_axis(2);
+	float viewdot = light_vec.normalized().dot(view_vec.normalized());
+
+
+	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);
+
+	// 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;
+
+	{
+
+		//fill pointcloud
+		Vector3* caster_pointcloud_ptr=&caster_pointcloud[0];
+
+		for(int i=0;i<caster_count;i++) {
+
+			Instance *ins = instance_shadow_cull_result[i];
+			if (!ins->visible || !ins->cast_shadows)
+				continue;
+
+			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_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 );
+
+	for(int i=0;i<cpcsize;i++) {
+
+		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);
+
+	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];
+
+		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;
+			} else {
+				light_space_pointcloud_aabb.expand_to(p);
+			}
+		}
+		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;
+			} else {
+				light_space_camera_aabb.expand_to(p);
+			}
+		}
+
+		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);
+	//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_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;
+
+	Vector3 pos = eye - up*(n-near_dist);
+
+	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();
+
+	//one possibility for a simple perspective transformation matrix
+	//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;
+
+	CameraMatrix projection = lisp_matrix * light_space_basis2;
+	//CameraMatrix projection = light_space_basis2 * lisp_matrix;
+
+
+	AABB proj_space_aabb;
+	float max_d,min_d;
+
+	{
+
+		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 p = projection.xform(caster_pointcloud_ptr[i]);
+			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++) {
+
+			Vector3 p = projection.xform(camera_pointcloud[i]);
+			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;
+	}
+
+	projection.scale_translate_to_fit(proj_space_aabb);
+	projection=projection * lisp_matrix;
+
+	CameraMatrix scale;
+	scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
+
+	projection=scale * projection;
+
+	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 );
+
+	for(int i=0;i<caster_count;i++) {
+
+		Instance *instance = instance_shadow_cull_result[i];
+
+		if (!instance->visible || !instance->cast_shadows)
+			continue;
+		_instance_draw(instance);
+	}
+
+	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) {
+
+	/* 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));
+
+	Vector3 up = light_vec.cross(view_vec).cross(light_vec).normalized();
+
+	Transform light_transform;
+	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;
+
+	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_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]);
+
+		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
+
+	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 );
+	//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 );
+	//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
+
+
+	/* 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);
+
+	/* STEP 4: ADJUST FAR Z PLANE */
+
+	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)
+			continue;
+
+		//@TODO optimize using support mapping
+		for(int j=0;j<8;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;
+
+		}
+
+	}
+
+	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;
+
+
+	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);
+		//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;
+
+		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;
+
+		Vector3 pos = p_camera->transform.origin - up*(n-near_dist);
+
+		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++) {
+
+			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));
+		}
+
+		CameraMatrix scaletrans;
+		scaletrans.scale_translate_to_fit(projection_bounds);
+		projection=scaletrans * lisp_matrix;
+
+		CameraMatrix scale;
+		scale.make_scale(Vector3(1.0,1.0,-1.0)); // transform to left handed
+
+		projection=scale * projection;
+
+
+		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->begin_shadow_map( p_light->light_info->instance,  0 );
+
+	for(int i=0;i<caster_count;i++) {
+
+		Instance *instance = instance_shadow_cull_result[i];
+
+		if (!instance->visible || !instance->cast_shadows)
+			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) {
+
+
+
+	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) {
+		
+		case Rasterizer::SHADOW_SIMPLE: {
+			/* SPOT SHADOW */
+
+
+			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 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 );
+
+			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);
+
+
+			for (int i=0;i<cull_count;i++) {
+
+				Instance *instance = instance_shadow_cull_result[i];
+				if (!instance->visible || !instance->cast_shadows)
+					continue;
+				_instance_draw(instance);
+			}
+
+			rasterizer->end_shadow_map();
+
+		} break;
+		case Rasterizer::SHADOW_DUAL_PARABOLOID: {
+
+			/* OMNI SHADOW */
+
+			int passes = rasterizer->light_instance_get_shadow_passes( p_light->light_info->instance );
+
+			if (passes==2) {
+
+				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 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);
+
+
+					for (int j=0;j<cull_count;j++) {
+
+						Instance *instance = instance_shadow_cull_result[j];
+						if (!instance->visible || !instance->cast_shadows)
+							continue;
+
+						_instance_draw(instance);
+					}
+
+					rasterizer->end_shadow_map();
+				}
+			} else if (passes==1) {
+				//one go
+
+
+
+			}
+
+		} break;
+		case Rasterizer::SHADOW_CUBE: {
+
+			// todo
+		} break;
+		case Rasterizer::SHADOW_ORTHOGONAL: {
+
+			_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);
+		} break;
+		case Rasterizer::SHADOW_PSM: {
+
+			_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) {
+
+	if (p_portal->portal_info->connected) {
+
+		//disconnect first
+		p_portal->portal_info->connected->portal_info->connected=NULL;
+		p_portal->portal_info->connected=NULL;
+
+	}
+
+	if (p_portal->room && p_portal->room->room) {
+
+		if (p_cleanup) {
+
+			p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
+			//p_portal->room->room->room_info->disconnected_child_portals.erase(p_portal);
+		} else {
+			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)
+		return;
+
+	p_geometry->valid_auto_rooms.clear();
+
+	int point_count = aabb_random_points.size();
+	const Vector3 * src_points = &aabb_random_points[0];
+
+	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];
+
+		//generate points
+		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));
+		}
+
+		int pass = room->room_info->room->bounds.get_points_inside(dst_points,point_count);
+
+		float ratio = (float)pass / point_count;
+
+		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 );
+	float A_surface = p_portal->portal_info->portal->bounds.get_area();
+	if (A_surface==0)
+		return; //wtf
+
+	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()) {
+
+		Instance *B = E->get();
+
+		if (B->portal_info->connected)
+			continue; // in use
+
+		Vector3 B_norm = B->data.transform.basis.get_axis(Vector3::AXIS_Z).normalized();
+
+		// check that they are in front of another
+		float dot = A_norm.dot(-B_norm);
+
+		if (dot<0.707) // 45 degrees, TODO unharcode this
+			continue;
+
+		// check the max distance to the other portal
+
+		bool valid=true;
+
+		Rect2 local_bounds;
+
+		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 ) );
+
+			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;
+				}
+
+
+			Vector3 point_local = affine_inverse.xform(A_plane.project(point));
+			point2 = Point2(point_local.x,point_local.y);
+
+			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)
+			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
+			continue;
+
+		found=B;
+		break;
+
+
+
+	}
+
+
+	if (!found) {
+
+		if (p_portal->room && p_portal->room->room) {
+
+			p_portal->room->room->room_info->disconnected_child_portals.insert(p_portal);
+		}
+
+		return;
+	}
+
+	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) {
+
+	VisualServerRaster *self = (VisualServerRaster*)p_self;
+	Instance *A = p_A;
+	Instance *B = p_B;
+
+	if (A->base_type==INSTANCE_PORTAL) {
+
+		ERR_FAIL_COND_V( B->base_type!=INSTANCE_PORTAL,NULL );
+
+		A->portal_info->candidate_set.insert(B);
+		B->portal_info->candidate_set.insert(A);
+
+		self->_portal_attempt_connect(A);
+		//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_ROOM || B->base_type==INSTANCE_ROOM) {
+
+		if (B->base_type==INSTANCE_ROOM)
+			SWAP(A,B);
+
+		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) {
+
+			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;
+	}
+
+	return NULL;
+
+}
+void VisualServerRaster::instance_unpair(void *p_self, OctreeElementID, Instance *p_A,int, OctreeElementID, Instance *p_B,int,void*) {
+
+	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 );
+
+
+		A->portal_info->candidate_set.erase(B);
+		B->portal_info->candidate_set.erase(A);
+
+		//after disconnecting them, see if they can connect again
+		self->_portal_attempt_connect(A);
+		self->_portal_attempt_connect(B);
+
+	} else if (A->base_type==INSTANCE_ROOM || B->base_type==INSTANCE_ROOM) {
+
+		if (B->base_type==INSTANCE_ROOM)
+			SWAP(A,B);
+
+		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 {
+
+
+		if (B->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;
+	}
+}
+
+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();
+
+	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];
+
+	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++) {
+
+		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);
+
+		bool all_over=true;
+
+		for(int j=0;j<dst_point_count;j++) {
+
+			if (!p.is_point_over(dst_points[j])) {
+
+				all_over=false;
+				break;
+			}
+
+		}
+
+		if (all_over) {
+			outside=true;
+			break;
+		}
+
+	}
+
+	return !outside;
+
+}
+
+void VisualServerRaster::_cull_portal(Camera *p_camera, Instance *p_portal,Instance *p_from_portal) {
+
+	ERR_FAIL_COND(!p_portal->scenario); //scenario outside
+
+	Instance *portal = p_portal;
+
+	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) {
+
+		return; //invalid portal, ignore
+	} else if (portal->portal_info->last_visited_pass==render_pass) {
+
+		return; //portal already visited
+	} else if (portal==p_from_portal) {
+
+		return; // came from this portal, don't even bother testing
+	}
+
+	/* TEST DISABLE DISTANCE */
+
+	float disable_distance = p_portal->portal_info->portal->disable_distance;
+	if (disable_distance) {
+		//has disable distance..
+		float distance = p_camera->transform.origin.distance_to(portal->data.transform.origin);
+		if (disable_distance < distance) {
+
+			return;
+		}
+	}
+
+	/* 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)
+
+			return;
+		}
+	} else {
+		//disconencted portals (go from room to parent room or exterior) must face towards the canera
+		if (!p_portal->portal_info->plane_cache.is_point_over(p_camera->transform.origin)) { //portal facing against camera (exterior)
+
+			return;
+		}
+	}
+
+	if (p_from_portal && !_test_portal_cull(p_camera, p_from_portal, portal)) {
+		return; // portal not visible (culled)
+	}
+
+	portal->portal_info->last_visited_pass=render_pass;
+
+	if (portal->portal_info->connected) {
+
+		//interior<->interior portal
+		Instance *to_room = portal->portal_info->connected->room;
+		if (!to_room) {
+			return; //wtf.. oh well, connected to a roomless (invalid) portal
+		}
+
+		_cull_room(p_camera, to_room, portal->portal_info->connected);
+
+	} else {
+		//to exterior/to parent roomportal
+
+		Instance *parent_room = portal->room->room;
+
+		_cull_room(p_camera, parent_room, portal);
+	}
+
+}
+
+void VisualServerRaster::_cull_room(Camera *p_camera, Instance *p_room,Instance *p_from_portal) {
+
+	if (p_room==NULL) {
+		//exterior
+		exterior_visited=true;
+
+		for(int i=0;i<exterior_portal_cull_count;i++) {
+
+			_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)
+			return; //this room is invalid
+
+		//interior
+		//first of all, validate the room
+		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()) {
+
+			_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::_render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario) {
+
+
+	uint64_t t = OS::get_singleton()->get_ticks_usec();
+	render_pass++;
+	uint32_t camera_layer_mask=p_camera->visible_layers;
+
+	/* STEP 1 - SETUP CAMERA */
+	CameraMatrix camera_matrix;
+	
+	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
+
+			);
+		} 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
+
+			);
+				
+		} break;		
+	}
+
+
+	rasterizer->set_camera(p_camera->transform, camera_matrix);
+	
+	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;
+
+	/* STEP 2 - CULL */
+	int cull_count = p_scenario->octree.cull_convex(planes,instance_cull_result,MAX_INSTANCE_CULL);
+	light_cull_count=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()));
+*/
+
+	/* STEP 3 - PROCESS PORTALS, VALIDATE ROOMS */
+	
+
+	// compute portals
+	
+	exterior_visited=false;
+	exterior_portal_cull_count=0;
+
+	if (room_cull_enabled) {
+		for(int i=0;i<cull_count;i++) {
+
+			Instance *ins = instance_cull_result[i];
+			ins->last_render_pass=render_pass;
+
+			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;
+
+		}
+
+		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;
+		//add to set
+		for(int i=0;i<room_cull_count;i++) {
+
+			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) {
+				//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]);
+				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++) {
+			Instance *r = room_cull_result[i];
+
+			//check inside BSP
+			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)) {
+
+				current_rooms.erase(r);
+				continue;
+			}
+
+			//check parent
+			while (r->room) {// has parent room
+
+				current_rooms.erase(r);
+				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());
+			}
+
+		} else {
+			//start from exterior
+			_cull_room(p_camera,NULL);
+
+		}
+	}
+
+	/* STEP 4 - REMOVE FURTHER CULLED OBJECTS, ADD LIGHTS */
+	
+	for(int i=0;i<cull_count;i++) {
+	
+		Instance *ins = instance_cull_result[i];
+				
+		bool keep=false;
+
+
+		if ((camera_layer_mask&ins->layer_mask)==0) {
+
+			//failure
+		} 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);
+				{
+					//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);
+				}
+			}
+
+		} else if ((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK && ins->visible) {
+
+
+			bool discarded=false;
+
+			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 (!discarded) {
+
+				// test if this geometry should be visible
+
+				if (room_cull_enabled) {
+
+
+					if (ins->visible_in_all_rooms) {
+						keep=true;
+					} else if (ins->room) {
+
+						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()) {
+
+							if (E->get()->room_info->last_visited_pass==render_pass) {
+								keep=true;
+								break;
+							}
+						}
+					} else if(exterior_visited)
+						keep=true;
+				} else {
+
+					keep=true;
+				}
+			}
+
+
+			if (keep) {
+				// update cull range
+				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 (!keep) {
+			// remove, no reason to keep
+			cull_count--;
+			SWAP( instance_cull_result[i], instance_cull_result[ cull_count ] );
+			i--;
+			ins->last_render_pass=0; // make invalid
+		} else {
+
+			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;
+	
+	/* STEP 5 - PROCESS LIGHTS */
+
+	rasterizer->shadow_clear_near(); //clear near shadows, will be recreated
+
+	// directional lights
+	{
+		List<RID>::Element *E=p_scenario->directional_lights.front();
+
+
+		while(E) {
+
+			Instance  *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
+
+			if (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);
+			}
+
+			E=E->next();
+		}
+	}
+
+
+	//discard lights not affecting anything (useful for deferred rendering, shadowmaps, etc)
+
+	for (int i=0;i<light_cull_count;i++) {
+	
+		Instance *ins = light_cull_result[i];
+
+		if (light_discard_enabled) {
+
+			//see if the light should be pre discarded because no one is seeing it
+			//this test may seem expensive, but in reality, it shouldn't be
+			//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) {
+
+				if (E->get()->last_render_pass==render_pass) {
+
+					valid=true; // early out.
+					break;
+				}
+				E=E->next();
+			}
+			if (!valid) {
+
+				light_cull_count--;
+				SWAP( light_cull_result[i], light_cull_result[ light_cull_count ] );
+				i--;
+
+			}
+		}
+		
+	}
+
+	{
+		//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++) {
+
+			Instance *ins = light_cull_result[i];
+
+			if (!rasterizer->light_has_shadow(ins->base_rid) || !shadows_enabled)
+				continue;
+			
+			/* for far shadows?
+			if (ins->version == ins->light_info->last_version && rasterizer->light_instance_has_far_shadow(ins->light_info->instance))
+				continue; // didn't change
+			*/
+					
+			_light_instance_update_shadow(ins,p_scenario,p_camera,cull_range);
+			ins->light_info->last_version=ins->version;
+		}
+	}
+
+
+
+	/* STEP 6 - PROCESS GEOMETRY AND DRAW SCENE*/
+		
+	RID environment;
+	if (p_camera->env.is_valid()) //camera has more environment priority
+		environment=p_camera->env;
+	else
+		environment=p_scenario->environment;
+
+	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();
+
+	
+		for(;E;E=E->next()) {
+			Instance  *light = E->get().is_valid()?instance_owner.get(E->get()):NULL;
+
+			ERR_CONTINUE(!light);
+			rasterizer->add_light(light->light_info->instance);
+			light->light_info->last_add_pass=render_pass;
+		}
+
+		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;
+		}
+	}
+		// add geometry
+
+	for(int i=0;i<cull_count;i++) {
+	
+		Instance *ins = instance_cull_result[i];
+
+		ERR_CONTINUE(!((1<<ins->base_type)&INSTANCE_GEOMETRY_MASK));
+		
+		_instance_draw(ins);
+	}
+
+	rasterizer->end_scene();
+}
+
+void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity) {
+
+	CanvasItem *ci = p_canvas_item;
+
+	if (!ci->visible)
+		return;
+
+	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;
+
+
+	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 size = rect.size;
+		size.x *= xform[0].length();
+		size.y *= xform[1].length();
+
+		_draw_viewport(vp,
+				from.x,
+				from.y,
+				size.x,
+				size.y);
+
+		rasterizer->canvas_begin();
+	}
+
+	int s = ci->commands.size();
+	bool reclip=false;
+
+	float opacity = ci->opacity * p_opacity;
+
+#ifndef ONTOP_DISABLED
+	CanvasItem **child_items = ci->child_items.ptr();
+	int child_item_count=ci->child_items.size();
+	int top_item_count=0;
+	CanvasItem **top_items=(CanvasItem**)alloca(child_item_count*sizeof(CanvasItem*));
+
+	if (ci->clip) {
+		rasterizer->canvas_set_clip(true,global_rect);
+		canvas_clip=global_rect;
+	}
+
+	for(int i=0;i<child_item_count;i++) {
+
+		if (child_items[i]->ontop)
+			top_items[top_item_count++]=child_items[i];
+		else {
+			_render_canvas_item(child_items[i],xform,p_clip_rect,opacity);
+		}
+	}
+#endif
+
+	if (s!=0) {
+
+		//Rect2 rect( ci->rect.pos + p_ofs, ci->rect.size);
+
+		if (p_clip_rect.intersects(global_rect)) {
+
+			rasterizer->canvas_begin_rect(xform);
+			rasterizer->canvas_set_opacity( opacity * ci->self_opacity );
+			rasterizer->canvas_set_blend_mode( ci->blend_mode );
+
+			CanvasItem::Command **commands = &ci->commands[0];
+
+			for (int i=0;i<s;i++) {
+
+				CanvasItem::Command *c=commands[i];
+
+				switch(c->type) {
+					case CanvasItem::Command::TYPE_LINE: {
+
+						CanvasItem::CommandLine* line = static_cast<CanvasItem::CommandLine*>(c);
+						rasterizer->canvas_draw_line(line->from,line->to,line->color,line->width);
+					} break;
+					case CanvasItem::Command::TYPE_RECT: {
+
+						CanvasItem::CommandRect* rect = static_cast<CanvasItem::CommandRect*>(c);
+//						rasterizer->canvas_draw_rect(rect->rect,rect->region,rect->source,rect->flags&CanvasItem::CommandRect::FLAG_TILE,rect->flags&CanvasItem::CommandRect::FLAG_FLIP_H,rect->flags&CanvasItem::CommandRect::FLAG_FLIP_V,rect->texture,rect->modulate);
+#if 0
+						int flags=0;
+
+						if (rect->flags&CanvasItem::CommandRect::FLAG_REGION) {
+							flags|=Rasterizer::CANVAS_RECT_REGION;
+						}
+						if (rect->flags&CanvasItem::CommandRect::FLAG_TILE) {
+							flags|=Rasterizer::CANVAS_RECT_TILE;
+						}
+						if (rect->flags&CanvasItem::CommandRect::FLAG_FLIP_H) {
+
+							flags|=Rasterizer::CANVAS_RECT_FLIP_H;
+						}
+						if (rect->flags&CanvasItem::CommandRect::FLAG_FLIP_V) {
+
+							flags|=Rasterizer::CANVAS_RECT_FLIP_V;
+						}
+#else
+
+						int flags=rect->flags;
+#endif
+						rasterizer->canvas_draw_rect(rect->rect,flags,rect->source,rect->texture,rect->modulate);
+
+					} break;
+					case CanvasItem::Command::TYPE_STYLE: {
+
+						CanvasItem::CommandStyle* style = static_cast<CanvasItem::CommandStyle*>(c);
+						rasterizer->canvas_draw_style_box(style->rect,style->texture,style->margin,style->draw_center,style->color);
+
+					} break;
+					case CanvasItem::Command::TYPE_PRIMITIVE: {
+
+						CanvasItem::CommandPrimitive* primitive = static_cast<CanvasItem::CommandPrimitive*>(c);
+						rasterizer->canvas_draw_primitive(primitive->points,primitive->colors,primitive->uvs,primitive->texture,primitive->width);
+					} break;
+					case CanvasItem::Command::TYPE_POLYGON: {
+
+						CanvasItem::CommandPolygon* polygon = static_cast<CanvasItem::CommandPolygon*>(c);
+						rasterizer->canvas_draw_polygon(polygon->count,polygon->indices.ptr(),polygon->points.ptr(),polygon->uvs.ptr(),polygon->colors.ptr(),polygon->texture,polygon->colors.size()==1);
+
+					} break;
+
+					case CanvasItem::Command::TYPE_POLYGON_PTR: {
+
+						CanvasItem::CommandPolygonPtr* polygon = static_cast<CanvasItem::CommandPolygonPtr*>(c);
+						rasterizer->canvas_draw_polygon(polygon->count,polygon->indices,polygon->points,polygon->uvs,polygon->colors,polygon->texture,false);
+					} break;
+					case CanvasItem::Command::TYPE_CIRCLE: {
+
+						CanvasItem::CommandCircle* circle = static_cast<CanvasItem::CommandCircle*>(c);
+						static const int numpoints=32;
+						Vector2 points[numpoints+1];
+						points[numpoints]=circle->pos;
+						int indices[numpoints*3];
+
+						for(int i=0;i<numpoints;i++) {
+
+							points[i]=circle->pos+Vector2( Math::sin(i*Math_PI*2.0/numpoints),Math::cos(i*Math_PI*2.0/numpoints) )*circle->radius;
+							indices[i*3+0]=i;
+							indices[i*3+1]=(i+1)%numpoints;
+							indices[i*3+2]=numpoints;
+						}
+						rasterizer->canvas_draw_polygon(numpoints*3,indices,points,NULL,&circle->color,RID(),true);
+						//rasterizer->canvas_draw_circle(circle->indices.size(),circle->indices.ptr(),circle->points.ptr(),circle->uvs.ptr(),circle->colors.ptr(),circle->texture,circle->colors.size()==1);
+					} break;
+					case CanvasItem::Command::TYPE_TRANSFORM: {
+
+						CanvasItem::CommandTransform* transform = static_cast<CanvasItem::CommandTransform*>(c);
+						rasterizer->canvas_set_transform(transform->xform);
+					} break;
+					case CanvasItem::Command::TYPE_BLEND_MODE: {
+
+						CanvasItem::CommandBlendMode* bm = static_cast<CanvasItem::CommandBlendMode*>(c);
+						rasterizer->canvas_set_blend_mode(bm->blend_mode);
+
+					} break;
+					case CanvasItem::Command::TYPE_CLIP_IGNORE: {
+
+						CanvasItem::CommandClipIgnore* ci = static_cast<CanvasItem::CommandClipIgnore*>(c);
+						if (canvas_clip!=Rect2()) {
+
+							if (ci->ignore!=reclip) {
+								if (ci->ignore) {
+
+									rasterizer->canvas_set_clip(false,Rect2());
+									reclip=true;
+								} else  {
+									rasterizer->canvas_set_clip(true,canvas_clip);
+									reclip=false;
+								}
+							}
+						}
+
+
+
+					} break;
+				}
+			}
+			rasterizer->canvas_end_rect();
+		}
+	}
+
+
+	if (reclip) {
+
+		rasterizer->canvas_set_clip(true,canvas_clip);
+	}
+
+#ifndef ONTOP_DISABLED
+
+	for(int i=0;i<top_item_count;i++) {
+
+		_render_canvas_item(top_items[i],xform,p_clip_rect,opacity);
+	}
+
+#else
+	for(int i=0;i<p_canvas_item->child_items.size();i++) {
+
+		_render_canvas_item(p_canvas_item->child_items[i],xform,p_clip_rect,opacity);
+	}
+#endif
+
+
+	if (ci->clip) {
+		rasterizer->canvas_set_clip(false,Rect2());
+		canvas_clip=Rect2();
+	}
+
+}
+
+void VisualServerRaster::_render_canvas(Canvas *p_canvas,const Matrix32 &p_transform) {
+
+	rasterizer->canvas_begin();
+
+	int l = p_canvas->child_items.size();
+
+	for(int i=0;i<l;i++) {
+
+		Canvas::ChildItem& ci=p_canvas->child_items[i];
+		_render_canvas_item(ci.item,p_transform,Rect2(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height),1);
+
+		//mirroring (useful for scrolling backgrounds)
+		if (ci.mirror.x!=0) {
+
+			Matrix32 xform2 = p_transform * Matrix32(0,Vector2(ci.mirror.x,0));
+			_render_canvas_item(ci.item,xform2,Rect2(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height),1);
+		}
+		if (ci.mirror.y!=0) {
+
+			Matrix32 xform2 = p_transform * Matrix32(0,Vector2(0,ci.mirror.y));
+			_render_canvas_item(ci.item,xform2,Rect2(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height),1);
+		}
+		if (ci.mirror.y!=0 && ci.mirror.x!=0) {
+
+			Matrix32 xform2 = p_transform * Matrix32(0,ci.mirror);
+			_render_canvas_item(ci.item,xform2,Rect2(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height),1);
+		}
+
+	}
+
+}
+
+
+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 old_rect = viewport_rect;
+//	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;
+	}
+
+	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 ) {
+
+
+		viewport_rect=desired_rect;
+		rasterizer->set_viewport(viewport_rect);		
+
+	}
+
+	/* Camera should always be BEFORE any other 3D */
+
+	if (!p_viewport->hide_scenario && camera_owner.owns(p_viewport->camera) && scenario_owner.owns(p_viewport->scenario)) {
+
+		Camera *camera = camera_owner.get( p_viewport->camera );
+		Scenario *scenario = scenario_owner.get( p_viewport->scenario );
+
+		_update_instances(); // check dirty instances before rendering
+
+		_render_camera(p_viewport, camera,scenario );
+
+	} else if (true /*|| !p_viewport->canvas_list.empty()*/){
+
+		//clear the viewport black because of no camera? i seriously should..
+		rasterizer->clear_viewport(clear_color);
+	}
+
+	if (!p_viewport->hide_canvas) {
+		int i=0;
+
+		Map<Viewport::CanvasKey,Viewport::CanvasData*> canvas_map;
+
+		for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
+			canvas_map[ Viewport::CanvasKey( E->key(), E->get().layer) ]=&E->get();
+
+		}
+
+		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("GT "+p_viewport->global_transform+". CT: "+E->get()->transform);
+			Matrix32 xform = p_viewport->global_transform * E->get()->transform;
+			_render_canvas( E->get()->canvas,xform );
+			i++;
+
+		}
+	}
+
+	//capture
+
+	if (p_viewport->queue_capture) {
+
+		rasterizer->capture_viewport(&p_viewport->capture);
+	}
+
+	//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 ) {
+
+		viewport_rect=old_rect;
+
+		rasterizer->set_viewport(viewport_rect);
+	}
+
+
+}
+
+void VisualServerRaster::_draw_viewports() {
+
+	//draw viewports for render targets
+	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
+		    ) {
+
+			continue;
+		}
+
+		rasterizer->set_render_target(vp->render_target);
+		_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) {
+			//was only enabled for capture
+			to_disable.push_back(vp);
+			vp->render_target_update_mode=RENDER_TARGET_UPDATE_DISABLED;
+		}
+
+	}
+
+	rasterizer->set_render_target(RID());
+
+	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 viewports attached to screen
+
+	for(Map<RID,int>::Element *E=screen_viewports.front();E;E=E->next()) {
+
+		Viewport *vp = viewport_owner.get(E->key());
+		ERR_CONTINUE(!vp);
+
+		int window_w = OS::get_singleton()->get_video_mode(E->get()).width;
+		int window_h = OS::get_singleton()->get_video_mode(E->get()).height;
+
+		_draw_viewport(vp,0,0,window_w,window_h);
+	}
+
+
+	//check when a viewport associated to a render target was drawn
+
+	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)
+			continue;
+		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;
+	int window_h = OS::get_singleton()->get_video_mode().height;
+
+	ViewportRect desired_rect;
+	desired_rect.x = desired_rect.y = 0;
+	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 ) {
+
+		viewport_rect=desired_rect;
+
+		rasterizer->set_viewport(viewport_rect);
+	}
+
+	rasterizer->canvas_begin();
+	rasterizer->canvas_begin_rect(Matrix32());
+
+	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 );
+		Point2 size(texture_get_width(tex), texture_get_height(tex));
+		rasterizer->canvas_draw_rect(Rect2(cursors[i].pos, size), 0, Rect2(), tex, Color(1, 1, 1, 1));
+	};
+
+	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));
+	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));
+	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));
+	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_end_rect();
+};
+
+void VisualServerRaster::flush() {
+	//do none
+}
+
+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);
+	rasterizer->begin_frame();
+	_draw_viewports();
+	_draw_cursors_and_margins();
+	rasterizer->end_frame();	
+	draw_extra_frame=rasterizer->needs_to_draw_next_frame();
+}
+
+bool VisualServerRaster::has_changed() const {
+
+	return changes>0 || draw_extra_frame;
+}
+
+int VisualServerRaster::get_render_info(RenderInfo p_info) {
+
+	return rasterizer->get_render_info(p_info);
+}
+
+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) {
+
+	clear_color=p_color;
+}
+
+void VisualServerRaster::set_boot_image(const Image& p_image, const Color& p_color) {
+
+	if (p_image.empty())
+		return;
+
+	rasterizer->begin_frame();
+
+	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;
+	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);
+	rasterizer->canvas_begin_rect(Matrix32());
+	Rect2 imgrect(0,0,p_image.get_width(),p_image.get_height());
+	Rect2 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,0));
+	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);
+	//default_scenario = scenario_create();
+	//default_viewport = viewport_create();
+	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));
+	transformed_aabb_random_points.resize(aabb_random_points.size());
+	changes=0;
+}
+
+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()) {
+		if (OS::get_singleton()->is_stdout_verbose()) {
+			lost++;
+		}
+		free(I->get());
+	}
+
+	if (lost)
+		print_line("VisualServerRaster: WARNING: Lost "+itos(lost)+" RIDs of type "+p_type);
+
+}
+
+void VisualServerRaster::finish() {
+
+
+	free(default_cursor_texture);
+
+	_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( &scenario_owner,"Scenario" );
+	_clean_up_owner( &instance_owner,"Instance" );
+	
+	_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 "+itos(instance_dependency_map.size()));
+	}
+	ERR_FAIL_COND( instance_dependency_map.size() );
+}
+
+
+RID VisualServerRaster::get_test_cube()  {
+
+	if (test_cube.is_valid())
+		return test_cube;
+		
+	test_cube=_make_test_cube();
+	return test_cube;	
+
+}
+
+
+
+VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer) {
+
+	rasterizer=p_rasterizer;
+	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()
+{
+}
+
+
diff --git a/servers/visual/visual_server_raster.h b/servers/visual/visual_server_raster.h
new file mode 100644
index 0000000000..f0b3a2d13c
--- /dev/null
+++ b/servers/visual/visual_server_raster.h
@@ -0,0 +1,1112 @@
+/*************************************************************************/
+/*  visual_server_raster.h                                               */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#ifndef VISUAL_SERVER_RASTER_H
+#define VISUAL_SERVER_RASTER_H
+
+
+#include "servers/visual_server.h"
+#include "servers/visual/rasterizer.h"
+#include "balloon_allocator.h"
+#include "octree.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,
+		INSTANCE_ROOMLESS_MASK=(1<<20)
+
+
+	};
+
+	struct Room {
+	
+		bool occlude_exterior;
+		BSP_Tree bounds;
+		Room() { occlude_exterior=true; }
+	};
+	
+	
+	BalloonAllocator<> octree_allocator;
+
+	struct OctreeAllocator {
+
+		static BalloonAllocator<> *allocator;
+
+		_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 {
+
+		bool enabled;
+		float disable_distance;
+		Color disable_color;
+		float connect_range;
+		Vector<Point2> shape;
+		Rect2 bounds;
+
+		Portal() { enabled=true; disable_distance=50; disable_color=Color(); connect_range=0.8; }
+	};
+
+
+	struct Camera  {
+ 
+		enum Type {
+			PERSPECTIVE,
+			ORTHOGONAL 	
+		};
+		Type type;
+		float fov;
+		float znear,zfar;
+		float size;
+		uint32_t visible_layers;
+		bool vaspect;
+		RID env;
+		
+		Transform transform;
+ 
+ 		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;
+	struct Scenario;
+	
+	struct Instance {
+			
+		enum {
+		
+			MAX_LIGHTS=4
+		};
+	
+		RID self;
+		OctreeElementID octree_id;		
+		Scenario *scenario;
+		bool update;
+		bool update_aabb;
+		Instance *update_next;				
+		InstanceType base_type;
+
+		RID base_rid;
+		
+		AABB aabb;
+		AABB transformed_aabb;
+		uint32_t object_ID;
+		bool visible;
+		bool cast_shadows;
+		bool receive_shadows;
+		bool visible_in_all_rooms;
+		uint32_t layer_mask;
+		float draw_range_begin;
+		float draw_range_end;
+		float extra_margin;
+
+
+		Rasterizer::InstanceData data;
+
+		
+		Set<Instance*> auto_rooms;
+		Set<Instance*> valid_auto_rooms;
+		Instance *room;
+		List<Instance*>::Element *RE;
+		bool exterior;
+
+		uint64_t last_render_pass;
+		uint64_t last_frame_pass;
+		
+		uint64_t version; // changes to this, and changes to base increase version
+		
+		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;
+			uint64_t last_visited_pass;
+			RoomInfo() { last_visited_pass=0; }
+
+		};
+
+		struct PortalInfo {
+
+			Portal *portal;
+			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;}
+		};
+
+		struct LightInfo {
+			
+			RID instance;						
+			int light_set_index;
+			uint64_t last_version;
+			uint64_t last_add_pass;
+			List<RID>::Element *D; // directional light in scenario
+			InstanceSet affected;
+			float dtc; //distance to camera, used for sorting
+
+			
+			LightInfo() {
+			
+				D=NULL;	
+				light_set_index=-1;
+				last_add_pass=0;
+			}
+		};
+		
+		struct ParticlesInfo {
+			
+			RID instance;			
+		};
+
+
+		RoomInfo *room_info;
+		LightInfo *light_info;
+		ParticlesInfo *particles_info;
+		PortalInfo * portal_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;
+			cast_shadows=true;
+			receive_shadows=true;
+			data.depth_scale=false;
+			data.billboard=false;
+			data.billboard_y=false;
+			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;
+
+			light_cache_dirty=true;
+
+		}
+		
+		~Instance() {
+		
+			if (light_info)
+				memdelete(light_info);
+			if (particles_info)
+				memdelete(particles_info);
+			if (room_info)
+				memdelete(room_info);
+			if (portal_info)
+				memdelete(portal_info);
+		};
+	};
+	
+	struct _InstanceLightsort {
+
+		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;
+		
+		Octree octree;
+			
+		List<RID> directional_lights;
+		RID environment;
+		
+		Instance *dirty_instances;
+
+		Scenario() { dirty_instances=NULL; debug=SCENARIO_DEBUG_DISABLED; }
+	};
+
+
+
+	
+
+	struct CanvasItem {
+		
+		struct Command {
+			
+			enum Type {
+				
+				TYPE_LINE,
+				TYPE_RECT,
+				TYPE_STYLE,
+				TYPE_PRIMITIVE,
+				TYPE_POLYGON,
+				TYPE_POLYGON_PTR,
+				TYPE_CIRCLE,
+				TYPE_TRANSFORM,
+				TYPE_BLEND_MODE,
+				TYPE_CLIP_IGNORE,
+			};
+			
+			Type type;
+		};
+		
+		struct CommandLine : public Command {
+			
+			Point2 from,to;
+			Color color;		
+			float width;
+			CommandLine() { type = TYPE_LINE; }
+		};
+		
+		struct CommandRect : public Command {
+			
+			Rect2 rect;
+			RID texture;
+			Color modulate;
+			Rect2 source;
+			uint8_t flags;
+			
+			CommandRect() { flags=0; type = TYPE_RECT; }
+		};
+			
+		struct CommandStyle : public Command {
+			
+			Rect2 rect;
+			RID texture;
+			float margin[4];
+			float draw_center;
+			Color color;
+			CommandStyle() { draw_center=true; type = TYPE_STYLE; }
+		};
+			
+		struct CommandPrimitive : public Command {
+			
+			Vector<Point2> points;
+			Vector<Point2> uvs;
+			Vector<Color> colors;
+			RID texture;
+			float width;
+			
+			CommandPrimitive() { type = TYPE_PRIMITIVE; width=1;}
+		};
+
+		struct CommandPolygon : public Command {
+
+			Vector<int> indices;
+			Vector<Point2> points;
+			Vector<Point2> uvs;
+			Vector<Color> colors;
+			RID texture;
+			int count;
+
+			CommandPolygon() { type = TYPE_POLYGON; count = 0; }
+		};
+
+		struct CommandPolygonPtr : public Command {
+
+			const int* indices;
+			const Point2* points;
+			const Point2* uvs;
+			const Color* colors;
+			RID texture;
+			int count;
+
+			CommandPolygonPtr() { type = TYPE_POLYGON_PTR; count = 0; }
+		};
+
+		struct CommandCircle : public Command {
+
+			Point2 pos;
+			float radius;
+			Color color;
+			CommandCircle() { type = TYPE_CIRCLE; }
+		};
+
+		struct CommandTransform : public Command {
+
+			Matrix32 xform;
+			CommandTransform() { type = TYPE_TRANSFORM; }
+		};
+
+		struct CommandBlendMode : public Command {
+
+			MaterialBlendMode blend_mode;
+			CommandBlendMode() { type = TYPE_BLEND_MODE; blend_mode = MATERIAL_BLEND_MODE_MIX; };
+		};
+		struct CommandClipIgnore : public Command {
+
+			bool ignore;
+			CommandClipIgnore() { type = TYPE_CLIP_IGNORE; ignore=false; };
+		};
+
+		RID parent; // canvas it belongs to
+		List<CanvasItem*>::Element *E;
+		Matrix32 xform;
+		bool clip;
+		bool visible;
+		bool ontop;
+		float opacity;
+		float self_opacity;
+		MaterialBlendMode blend_mode;
+		RID viewport;
+
+		mutable bool custom_rect;
+		mutable bool rect_dirty;
+		mutable Rect2 rect;
+		
+		Vector<Command*> commands;
+		Vector<CanvasItem*> child_items;
+
+		const Rect2& get_rect() const;
+		void clear() { for (int i=0;i<commands.size();i++) memdelete( commands[i] ); commands.clear(); clip=false; rect_dirty=true;};
+		CanvasItem() { clip=false; E=NULL; opacity=1; self_opacity=1; blend_mode=MATERIAL_BLEND_MODE_MIX; visible=true; rect_dirty=true; custom_rect=false; ontop=true; }
+		~CanvasItem() { clear(); }
+	};
+
+
+
+	struct Canvas {
+
+		Set<RID> viewports;
+		struct ChildItem {
+
+			Point2 mirror;
+			CanvasItem *item;
+		};
+
+
+		Vector<ChildItem> child_items;
+
+		int find_item(CanvasItem *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)
+				child_items.remove(idx);
+		}
+
+		Canvas() {  }
+		
+	};
+
+
+
+	struct Viewport {
+
+		RID self;
+		RID parent;
+
+		VisualServer::ViewportRect rect;
+		RID camera;
+		RID scenario;
+		RID viewport_data;
+
+		RenderTargetUpdateMode render_target_update_mode;
+		RID render_target;
+		RID render_target_texture;
+
+		bool hide_scenario;
+		bool hide_canvas;
+		bool transparent_bg;
+
+		bool queue_capture;
+		Image capture;
+
+		bool rendered_in_prev_frame;
+
+		struct CanvasKey {
+
+			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; }
+		};
+
+		struct CanvasData {
+
+			Canvas *canvas;
+			Matrix32 transform;
+			int layer;
+		};
+
+		Matrix32 global_transform;
+
+		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;}
+	};
+
+	SelfList<Viewport>::List viewport_update_list;
+
+	Map<RID,int> screen_viewports;
+
+	struct CullRange {
+	
+		Plane nearp;
+		float min,max;
+		float z_near,z_far;
+		
+		void add_aabb(const AABB& p_aabb) {
+		
+		
+		}
+	};
+
+	struct Cursor {
+
+		Point2 pos;
+		float rot;
+		RID texture;
+		Point2 center;
+		bool visible;
+		Cursor() {
+
+			rot = 0;
+			visible = false;
+		};
+	};
+
+	Rect2 canvas_clip;
+	Color clear_color;
+	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*);
+
+	Instance *instance_cull_result[MAX_INSTANCE_CULL];
+	Instance *instance_shadow_cull_result[MAX_INSTANCE_CULL]; //used for generating shadowmaps
+	Instance *light_cull_result[MAX_LIGHTS_CULLED];	
+	int light_cull_count;
+
+	Instance *exterior_portal_cull_result[MAX_EXTERIOR_PORTALS];
+	int exterior_portal_cull_count;
+	bool exterior_visited;	
+
+	Instance *room_cull_result[MAX_ROOM_CULL];
+	int room_cull_count;
+	bool room_cull_enabled;
+	bool light_discard_enabled;
+	bool shadows_enabled;
+	int black_margin[4];
+
+	Vector<Vector3> aabb_random_points;
+	Vector<Vector3> transformed_aabb_random_points;
+
+	void _instance_validate_autorooms(Instance *p_geometry);
+
+	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);
+	void _instance_queue_update(Instance *p_instance,bool p_update_aabb=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);
+	
+	Instance *instance_update_list;
+
+	//RID default_scenario;
+	//RID default_viewport;
+
+	RID test_cube;
+
+	
+	mutable RID_Owner<Room> room_owner;
+	mutable RID_Owner<Portal> portal_owner;
+	
+	mutable RID_Owner<Camera> camera_owner;
+	mutable RID_Owner<Viewport> viewport_owner;
+	
+	mutable RID_Owner<Scenario> scenario_owner;
+	mutable RID_Owner<Instance> instance_owner;
+	
+	mutable RID_Owner<Canvas> canvas_owner;
+	mutable RID_Owner<CanvasItem> canvas_item_owner;
+
+	Map< RID, Set<RID> > instance_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 _render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario);
+	void _render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect,float p_opacity);
+	void _render_canvas(Canvas *p_canvas,const Matrix32 &p_transform);
+	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_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(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:
+
+	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 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 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;
+
+
+	/* SHADER API */
+	
+	virtual RID shader_create(ShaderMode p_mode=SHADER_MATERIAL);
+
+	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,int p_vertex_ofs=0,int p_fragment_ofs=0);
+	virtual String shader_get_vertex_code(RID p_shader) const;
+	virtual String shader_get_fragment_code(RID p_shader) const;
+
+	virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) const;
+
+	/* COMMON MATERIAL API */
+
+	virtual RID material_create();
+
+	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_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_hint(RID p_material, MaterialHint p_hint,bool p_enabled);
+	virtual bool material_get_hint(RID p_material,MaterialHint p_hint) const;
+
+	virtual void material_set_shade_model(RID p_material, MaterialShadeModel p_model);
+	virtual MaterialShadeModel material_get_shade_model(RID p_material) const;
+
+	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 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_detail_blend_mode(RID p_material,MaterialBlendMode p_mode);
+	virtual MaterialBlendMode fixed_material_get_detail_blend_mode(RID p_material) 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 Transform fixed_material_get_uv_transform(RID p_material) const;
+
+	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 int mesh_get_morph_target_count(RID p_mesh) const;
+
+	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_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 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;
+	virtual int mesh_surface_get_array_index_len(RID p_mesh, int p_surface) const;
+	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 int mesh_get_surface_count(RID p_mesh) const;
+		
+
+	/* MULTIMESH API */
+
+	virtual RID multimesh_create();
+	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 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 void multimesh_set_visible_instances(RID p_multimesh,int p_visible);
+	virtual int multimesh_get_visible_instances(RID p_multimesh) const;
+
+	
+	/* PARTICLES API */
+	
+	virtual RID particles_create();
+	
+	virtual void particles_set_amount(RID p_particles, int p_amount);
+	virtual int particles_get_amount(RID p_particles) const;
+		
+	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 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 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 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 DVector<Vector3> particles_get_emission_points(RID p_particles) const;
+
+	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 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 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);
+	virtual float particles_get_color_phase_pos(RID p_particles, int p_phase) const;
+	
+	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 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_strength(RID p_particles, int p_attractor, float p_force);
+	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 RID particles_get_material(RID p_particles) const;
+		
+	virtual void particles_set_height_from_velocity(RID p_particles, bool p_enable);
+	virtual bool particles_has_height_from_velocity(RID p_particles) const;
+
+	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_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 bool light_is_volumetric(RID p_light) const;	
+			
+	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 LightOp light_get_operator(RID p_light) const;
+
+	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 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;
+
+
+	/* SKELETON API */
+	
+	virtual RID skeleton_create();
+	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);
+
+	/* ROOM API */
+
+	virtual RID room_create();
+	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 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 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;
+
+
+			
+	/* 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_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 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;
+
+	/* VIEWPORT API */
+
+	virtual RID viewport_create();
+
+	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 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_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 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_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 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 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 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_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_environment(RID p_scenario, RID p_environment);
+	virtual RID scenario_get_environment(RID p_scenario, RID p_environment) const;
+
+		
+	/* INSTANCING API */
+	
+	virtual RID instance_create();
+
+	virtual void instance_set_base(RID p_instance, RID p_base);
+	virtual RID instance_get_base(RID p_instance) const;
+
+	virtual void instance_set_scenario(RID p_instance, RID p_scenario);
+	virtual RID instance_get_scenario(RID p_instance) const;
+
+	virtual void instance_set_layer_mask(RID p_instance, uint32_t p_mask);
+	virtual uint32_t instance_get_layer_mask(RID p_instance) const;
+
+	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 uint32_t instance_get_object_instance_ID(RID p_instance) const;
+
+	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_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_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 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_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 float instance_geometry_get_draw_range_max(RID p_instance) const;
+	virtual float instance_geometry_get_draw_range_min(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 RID canvas_item_create();
+
+	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 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_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_clip(RID p_item, bool p_clip);
+	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);
+	virtual bool canvas_item_is_on_top(RID p_item) const;
+
+	virtual void canvas_item_set_self_opacity(RID p_item, float p_self_opacity);
+	virtual float canvas_item_get_self_opacity(RID p_item, float p_self_opacity) const;
+
+	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));
+	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));
+	virtual void canvas_item_add_style_box(RID p_item, const Rect2& p_rect, 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_clear(RID p_item);
+	virtual void canvas_item_raise(RID p_item);
+
+	/* 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);
+	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);
+
+	/* BLACK BARS */
+
+	virtual void black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom);
+
+	/* FREE */
+	
+	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 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;
+
+	/* EVENT QUEUING */
+
+	virtual void draw();
+	virtual void flush();
+
+	virtual void init();	
+	virtual void finish();
+
+	virtual bool has_changed() const;
+
+	/* RENDER INFO */
+
+	virtual int get_render_info(RenderInfo p_info);
+	virtual bool has_feature(Features p_feature) const;
+
+	RID get_test_cube();
+
+	virtual void set_boot_image(const Image& p_image, const Color& p_color);
+	virtual void set_default_clear_color(const Color& p_color);
+
+	VisualServerRaster(Rasterizer *p_rasterizer);	
+	~VisualServerRaster();
+
+};
+
+#endif
diff --git a/servers/visual/visual_server_wrap_mt.cpp b/servers/visual/visual_server_wrap_mt.cpp
new file mode 100644
index 0000000000..85f7b8c3cb
--- /dev/null
+++ b/servers/visual/visual_server_wrap_mt.cpp
@@ -0,0 +1,199 @@
+/*************************************************************************/
+/*  visual_server_wrap_mt.cpp                                            */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#include "visual_server_wrap_mt.h"
+#include "os/os.h"
+
+void VisualServerWrapMT::thread_exit() {
+
+	exit=true;
+}
+
+void VisualServerWrapMT::thread_draw() {
+	
+	
+	draw_mutex->lock();
+	
+	draw_pending--;
+	bool draw=(draw_pending==0);// only draw when no more flushes are pending
+	
+	draw_mutex->unlock();
+	
+	if (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);
+	
+
+	vsmt->thread_loop();
+}	
+
+void VisualServerWrapMT::thread_loop() {
+
+	server_thread=Thread::get_caller_ID();
+
+	OS::get_singleton()->make_rendering_thread();
+
+	visual_server->init();
+	
+	exit=false;
+	draw_thread_up=true;
+	while(!exit) {
+		// flush commands one by one, until exit is requested
+		command_queue.wait_and_flush_one();
+	}
+	
+	command_queue.flush_all(); // flush all
+	
+	visual_server->finish();
+	
+}
+
+
+/* EVENT QUEUING */
+
+void VisualServerWrapMT::flush() {
+
+	if (create_thread) {
+
+		ERR_FAIL_COND(!draw_mutex);
+		draw_mutex->lock();
+		draw_pending++; //cambiar por un saferefcount
+		draw_mutex->unlock();
+
+		command_queue.push( this, &VisualServerWrapMT::thread_flush);
+	} else {
+
+		command_queue.flush_all(); //flush all pending from other threads
+	}
+
+}
+
+void VisualServerWrapMT::draw() {
+	
+
+	if (create_thread) {
+
+		ERR_FAIL_COND(!draw_mutex);
+		draw_mutex->lock();
+		draw_pending++; //cambiar por un saferefcount
+		draw_mutex->unlock();
+
+		command_queue.push( this, &VisualServerWrapMT::thread_draw);
+	} else {
+
+		command_queue.flush_all(); //flush all pending from other threads
+		visual_server->draw();
+	}
+}
+
+
+void VisualServerWrapMT::init() {
+
+	if (create_thread) {
+
+		draw_mutex = Mutex::create();
+		print_line("CREATING RENDER THREAD");
+		OS::get_singleton()->release_rendering_thread();
+		if (create_thread) {
+			thread = Thread::create( _thread_callback, this );
+			print_line("STARTING RENDER THREAD");
+		}
+		while(!draw_thread_up) {
+			OS::get_singleton()->delay_usec(1000);
+		}
+		print_line("DONE RENDER THREAD");
+	} else {
+
+		visual_server->init();
+	}
+		
+}
+
+void VisualServerWrapMT::finish() {
+
+
+	if (thread) {
+
+		command_queue.push( this, &VisualServerWrapMT::thread_exit);
+		Thread::wait_to_finish( thread );
+		memdelete(thread);
+		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) {
+
+	visual_server=p_contained;
+	create_thread=p_create_thread;
+	thread=NULL;
+	draw_mutex=NULL;
+	draw_pending=0;
+	draw_thread_up=false;
+	if (!p_create_thread) {
+		server_thread=Thread::get_caller_ID();
+	} else {
+		server_thread=0;
+	}
+}
+
+
+VisualServerWrapMT::~VisualServerWrapMT() {
+
+	memdelete(visual_server);
+	//finish();
+
+}
+
+
diff --git a/servers/visual/visual_server_wrap_mt.h b/servers/visual/visual_server_wrap_mt.h
new file mode 100644
index 0000000000..3d227cfdbc
--- /dev/null
+++ b/servers/visual/visual_server_wrap_mt.h
@@ -0,0 +1,1057 @@
+/*************************************************************************/
+/*  visual_server_wrap_mt.h                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                    http://www.godotengine.org                         */
+/*************************************************************************/
+/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur.                 */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+#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"
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+class VisualServerWrapMT : public VisualServer {
+
+	// the real visual server
+	mutable VisualServer *visual_server;
+	
+	mutable CommandQueueMT command_queue;
+	
+	static void _thread_callback(void *_instance);
+	void thread_loop();
+
+	Thread::ID server_thread;
+	volatile bool exit;
+	Thread *thread;
+	volatile bool draw_thread_up;
+	bool create_thread;
+	
+	Mutex *draw_mutex;
+	int draw_pending;
+	void thread_draw();
+	void thread_flush();
+
+	void thread_exit();
+
+public:
+
+#define FUNC0R(m_r,m_func)\
+	virtual m_r m_func() { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func();\
+		}\
+	}
+
+#define FUNC0RC(m_r,m_func)\
+	virtual m_r m_func() const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func();\
+		}\
+	}
+
+
+#define FUNC0(m_func)\
+	virtual void m_func() { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func);\
+		} else {\
+			visual_server->m_func();\
+		}\
+	}
+
+#define FUNC0C(m_func)\
+	virtual void m_func() const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func);\
+		} else {\
+			visual_server->m_func();\
+		}\
+	}
+
+
+#define FUNC0S(m_func)\
+	virtual void m_func() { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func);\
+		} else {\
+			visual_server->m_func();\
+		}\
+	}
+
+#define FUNC0SC(m_func)\
+	virtual void m_func() const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func);\
+		} else {\
+			visual_server->m_func();\
+		}\
+	}
+
+
+///////////////////////////////////////////////
+
+
+#define FUNC1R(m_r,m_func,m_arg1)\
+	virtual m_r m_func(m_arg1 p1) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1);\
+		}\
+	}
+
+#define FUNC1RC(m_r,m_func,m_arg1)\
+	virtual m_r m_func(m_arg1 p1) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1);\
+		}\
+	}
+
+
+#define FUNC1S(m_func,m_arg1)\
+	virtual void m_func(m_arg1 p1) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1);\
+		} else {\
+			visual_server->m_func(p1);\
+		}\
+	}
+
+#define FUNC1SC(m_func,m_arg1)\
+	virtual void m_func(m_arg1 p1) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1);\
+		} else {\
+			visual_server->m_func(p1);\
+		}\
+	}
+
+
+#define FUNC1(m_func,m_arg1)\
+	virtual void m_func(m_arg1 p1) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1);\
+		} else {\
+			visual_server->m_func(p1);\
+		}\
+	}
+
+#define FUNC1C(m_func,m_arg1)\
+	virtual void m_func(m_arg1 p1) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1);\
+		} else {\
+			visual_server->m_func(p1);\
+		}\
+	}
+
+
+
+
+#define FUNC2R(m_r,m_func,m_arg1, m_arg2)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2);\
+		}\
+	}
+
+#define FUNC2RC(m_r,m_func,m_arg1, m_arg2)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2);\
+		}\
+	}
+
+
+#define FUNC2S(m_func,m_arg1, m_arg2)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2);\
+		} else {\
+			visual_server->m_func(p1, p2);\
+		}\
+	}
+
+#define FUNC2SC(m_func,m_arg1, m_arg2)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2);\
+		} else {\
+			visual_server->m_func(p1, p2);\
+		}\
+	}
+
+
+#define FUNC2(m_func,m_arg1, m_arg2)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2);\
+		} else {\
+			visual_server->m_func(p1, p2);\
+		}\
+	}
+
+#define FUNC2C(m_func,m_arg1, m_arg2)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2);\
+		} else {\
+			visual_server->m_func(p1, p2);\
+		}\
+	}
+
+
+
+
+#define FUNC3R(m_r,m_func,m_arg1, m_arg2, m_arg3)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+#define FUNC3RC(m_r,m_func,m_arg1, m_arg2, m_arg3)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+
+#define FUNC3S(m_func,m_arg1, m_arg2, m_arg3)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3);\
+		} else {\
+			visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+#define FUNC3SC(m_func,m_arg1, m_arg2, m_arg3)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3);\
+		} else {\
+			visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+
+#define FUNC3(m_func,m_arg1, m_arg2, m_arg3)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3);\
+		} else {\
+			visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+#define FUNC3C(m_func,m_arg1, m_arg2, m_arg3)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3);\
+		} else {\
+			visual_server->m_func(p1, p2, p3);\
+		}\
+	}
+
+
+
+
+#define FUNC4R(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+#define FUNC4RC(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+
+#define FUNC4S(m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+#define FUNC4SC(m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+
+#define FUNC4(m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+#define FUNC4C(m_func,m_arg1, m_arg2, m_arg3, m_arg4)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4);\
+		}\
+	}
+
+
+
+
+#define FUNC5R(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+#define FUNC5RC(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+
+#define FUNC5S(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+#define FUNC5SC(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+
+#define FUNC5(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+#define FUNC5C(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5);\
+		}\
+	}
+
+
+
+
+#define FUNC6R(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+#define FUNC6RC(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+
+#define FUNC6S(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+#define FUNC6SC(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+
+#define FUNC6(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+#define FUNC6C(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6);\
+		}\
+	}
+
+
+
+
+#define FUNC7R(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+#define FUNC7RC(m_r,m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual m_r m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			m_r ret;\
+			command_queue.push_and_ret( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7,&ret);\
+			return ret;\
+		} else {\
+			return visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+
+#define FUNC7S(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+#define FUNC7SC(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push_and_sync( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+
+#define FUNC7(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+#define FUNC7C(m_func,m_arg1, m_arg2, m_arg3, m_arg4, m_arg5, m_arg6, m_arg7)\
+	virtual void m_func(m_arg1 p1, m_arg2 p2, m_arg3 p3, m_arg4 p4, m_arg5 p5, m_arg6 p6, m_arg7 p7) const { \
+		if (Thread::get_caller_ID()!=server_thread) {\
+			command_queue.push( visual_server, &VisualServer::m_func,p1, p2, p3, p4, p5, p6, p7);\
+		} else {\
+			visual_server->m_func(p1, p2, p3, p4, p5, p6, p7);\
+		}\
+	}
+
+
+
+
+	FUNC0R(RID,texture_create);
+	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&);
+
+	/* SHADER API */
+
+	FUNC1R(RID,shader_create,ShaderMode);
+	FUNC2(shader_set_mode,RID,ShaderMode);
+	FUNC1RC(ShaderMode,shader_get_mode,RID);
+	FUNC5(shader_set_code,RID,const String&,const String&,int,int);
+	FUNC1RC(String,shader_get_vertex_code,RID);
+	FUNC1RC(String,shader_get_fragment_code,RID);
+	FUNC2SC(shader_get_param_list,RID,List<PropertyInfo>*);
+
+	/*virtual void shader_get_param_list(RID p_shader, List<PropertyInfo> *p_param_list) {
+		if (Thread::get_caller_ID()!=server_thread) {
+			command_queue.push_and_sync( visual_server, &VisualServer::shader_get_param_list,p_shader,p_param_list);
+		} else {
+			visual_server->m_func(p1, p2, p3, p4, p5);
+		}
+	}*/
+
+//	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);
+
+	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_hint,RID,MaterialHint,bool);
+	FUNC2RC(bool,material_get_hint,RID,MaterialHint);
+
+	FUNC2(material_set_shade_model,RID,MaterialShadeModel);
+	FUNC1RC(MaterialShadeModel,material_get_shade_model,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);
+
+	/* FIXED MATERIAL */
+
+
+	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_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);
+
+	FUNC2(fixed_material_set_detail_blend_mode,RID ,MaterialBlendMode );
+	FUNC1RC(MaterialBlendMode, fixed_material_get_detail_blend_mode,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_point_size,RID ,float);
+	FUNC1RC(float,fixed_material_get_point_size,RID);
+
+	/* SURFACE API */
+	FUNC0R(RID,mesh_create);
+
+	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
+
+	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);
+
+	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_remove_surface,RID,int);
+	FUNC1RC(int,mesh_get_surface_count,RID);
+
+
+
+	/* MULTIMESH API */
+
+	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&);
+
+	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);
+
+
+	/* PARTICLES API */
+
+	FUNC0R(RID,particles_create);
+
+	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_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_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_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_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 );
+
+	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 );
+
+	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_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);
+
+	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 );
+
+
+	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_projector,RID,RID );
+	FUNC1RC(RID,light_get_projector,RID);
+
+	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_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 );
+
+	/* ROOM API */
+
+	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);
+
+
+
+	/* 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);
+
+	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);
+
+
+	/* VIEWPORT API */
+
+	FUNC0R(RID,viewport_create);
+
+	FUNC2(viewport_attach_to_screen,RID,int );
+	FUNC1(viewport_detach,RID);
+
+	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);
+
+	FUNC1(viewport_queue_screen_capture,RID);
+	FUNC1RC(Image,viewport_get_screen_capture,RID);
+
+	FUNC2(viewport_set_rect,RID,const ViewportRect&);
+	FUNC1RC(ViewportRect,viewport_get_rect,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 );
+
+	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);
+
+	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_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);
+
+
+	/* INSTANCING API */
+
+	FUNC0R(RID,instance_create);
+
+	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_layer_mask,RID, uint32_t);
+	FUNC1RC(uint32_t,instance_get_layer_mask,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_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);
+
+	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_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 );
+
+	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 );
+
+	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);
+
+
+	/* CANVAS (2D) */
+
+	FUNC0R(RID,canvas_create);
+	FUNC3(canvas_set_item_mirroring,RID,RID,const Point2&);
+	FUNC2RC(Point2,canvas_get_item_mirroring,RID,RID);
+
+	FUNC0R(RID,canvas_item_create);
+
+	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_blend_mode,RID,MaterialBlendMode );
+
+
+	//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 );
+	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_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& );
+	FUNC5(canvas_item_add_texture_rect,RID, const Rect2& , RID ,bool ,const Color& );
+	FUNC5(canvas_item_add_texture_rect_region,RID, const Rect2& , RID ,const Rect2& ,const Color& );
+
+	FUNC7(canvas_item_add_style_box,RID, 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 );
+
+	FUNC1(canvas_item_clear,RID);
+	FUNC1(canvas_item_raise,RID);
+
+
+	/* CURSOR */
+	FUNC2(cursor_set_rotation,float , int ); // radians
+	FUNC3(cursor_set_texture,RID , const Point2 &, int );
+	FUNC2(cursor_set_visible,bool , int );
+	FUNC2(cursor_set_pos,const Point2& , int );
+
+	/* BLACK BARS */
+
+	FUNC4(black_bars_set_margins,int , int , int , int );
+
+	/* FREE */
+
+	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>* );
+
+	/* EVENT QUEUING */
+
+
+	virtual void init();
+	virtual void finish();
+	virtual void draw();
+	virtual void flush();
+	FUNC0RC(bool,has_changed);
+
+	/* RENDER INFO */
+
+	FUNC1R(int,get_render_info,RenderInfo );
+	FUNC1RC(bool,has_feature,Features );
+
+	FUNC2(set_boot_image,const Image& , const Color& );
+	FUNC1(set_default_clear_color,const Color& );
+
+	FUNC0R(RID,get_test_cube );
+
+
+	VisualServerWrapMT(VisualServer* p_contained,bool p_create_thread);
+	~VisualServerWrapMT();
+
+};
+
+
+#endif