19 files changed, 1015 insertions, 412 deletions

diff --git a/servers/physics_2d/body_2d_sw.cpp b/servers/physics_2d/body_2d_sw.cpp
index d93d4d5c35..1cfe9a6ab9 100644
--- a/servers/physics_2d/body_2d_sw.cpp
+++ b/servers/physics_2d/body_2d_sw.cpp
@@ -647,6 +647,7 @@ Body2DSW::Body2DSW() : CollisionObject2DSW(TYPE_BODY), active_list(this), inerti
 	area_linear_damp=0;
 	contact_count=0;
 	gravity_scale=1.0;
+	one_way_collision_max_depth=0.1;
 
 	still_time=0;
 	continuous_cd_mode=Physics2DServer::CCD_MODE_DISABLED;
diff --git a/servers/physics_2d/body_2d_sw.h b/servers/physics_2d/body_2d_sw.h
index 5bd68ba976..3b87be2737 100644
--- a/servers/physics_2d/body_2d_sw.h
+++ b/servers/physics_2d/body_2d_sw.h
@@ -67,6 +67,9 @@ class Body2DSW : public CollisionObject2DSW {
 	Vector2 applied_force;
 	real_t applied_torque;
 
+	Vector2 one_way_collision_direction;
+	float one_way_collision_max_depth;
+
 
 	SelfList<Body2DSW> active_list;
 	SelfList<Body2DSW> inertia_update_list;
@@ -216,6 +219,12 @@ public:
 	_FORCE_INLINE_ void set_continuous_collision_detection_mode(Physics2DServer::CCDMode p_mode) { continuous_cd_mode=p_mode; }
 	_FORCE_INLINE_ Physics2DServer::CCDMode get_continuous_collision_detection_mode() const { return continuous_cd_mode; }
 
+	void set_one_way_collision_direction(const Vector2& p_dir) { one_way_collision_direction=p_dir; }
+	Vector2 get_one_way_collision_direction() const { return one_way_collision_direction; }
+
+	void set_one_way_collision_max_depth(float p_depth) { one_way_collision_max_depth=p_depth; }
+	float get_one_way_collision_max_depth() const { return one_way_collision_max_depth; }
+
 	void set_space(Space2DSW *p_space);
 
 	void update_inertias();
diff --git a/servers/physics_2d/physics_2d_server_sw.cpp b/servers/physics_2d/physics_2d_server_sw.cpp
index ab85f5e1d6..be49955055 100644
--- a/servers/physics_2d/physics_2d_server_sw.cpp
+++ b/servers/physics_2d/physics_2d_server_sw.cpp
@@ -138,6 +138,21 @@ void Physics2DServerSW::_shape_col_cbk(const Vector2& p_point_A,const Vector2& p
 	if (cbk->max==0)
 		return;
 
+	if (cbk->valid_dir!=Vector2()) {
+		if (p_point_A.distance_squared_to(p_point_B)>cbk->valid_depth*cbk->valid_depth) {
+			return;
+		}
+		if (cbk->valid_dir.dot((p_point_A-p_point_B).normalized())<0.7071) {
+/*			print_line("A: "+p_point_A);
+			print_line("B: "+p_point_B);
+			print_line("discard too angled "+rtos(cbk->valid_dir.dot((p_point_A-p_point_B))));
+			print_line("resnorm: "+(p_point_A-p_point_B).normalized());
+			print_line("distance: "+rtos(p_point_A.distance_to(p_point_B)));
+*/
+			return;
+		}
+	}
+
 	if (cbk->amount == cbk->max) {
 		//find least deep
 		float min_depth=1e20;
@@ -860,6 +875,37 @@ int Physics2DServerSW::body_get_max_contacts_reported(RID p_body) const {
 	return body->get_max_contacts_reported();
 }
 
+void Physics2DServerSW::body_set_one_way_collision_direction(RID p_body,const Vector2& p_direction) {
+
+	Body2DSW *body = body_owner.get(p_body);
+	ERR_FAIL_COND(!body);
+	body->set_one_way_collision_direction(p_direction);
+}
+
+Vector2 Physics2DServerSW::body_get_one_way_collision_direction(RID p_body) const{
+
+	Body2DSW *body = body_owner.get(p_body);
+	ERR_FAIL_COND_V(!body,Vector2());
+	return body->get_one_way_collision_direction();
+
+}
+
+void Physics2DServerSW::body_set_one_way_collision_max_depth(RID p_body,float p_max_depth) {
+
+	Body2DSW *body = body_owner.get(p_body);
+	ERR_FAIL_COND(!body);
+	body->set_one_way_collision_max_depth(p_max_depth);
+
+}
+
+float Physics2DServerSW::body_get_one_way_collision_max_depth(RID p_body) const {
+
+	Body2DSW *body = body_owner.get(p_body);
+	ERR_FAIL_COND_V(!body,0);
+	return body->get_one_way_collision_max_depth();
+
+}
+
 void Physics2DServerSW::body_set_force_integration_callback(RID p_body,Object *p_receiver,const StringName& p_method,const Variant& p_udata) {
 
 
diff --git a/servers/physics_2d/physics_2d_server_sw.h b/servers/physics_2d/physics_2d_server_sw.h
index 9edd4eee11..e9c499aaff 100644
--- a/servers/physics_2d/physics_2d_server_sw.h
+++ b/servers/physics_2d/physics_2d_server_sw.h
@@ -71,6 +71,8 @@ public:
 
 	struct CollCbkData {
 
+		Vector2 valid_dir;
+		float valid_depth;
 		int max;
 		int amount;
 		Vector2 *ptr;
@@ -205,6 +207,13 @@ public:
 	virtual void body_set_max_contacts_reported(RID p_body, int p_contacts);
 	virtual int body_get_max_contacts_reported(RID p_body) const;
 
+	virtual void body_set_one_way_collision_direction(RID p_body,const Vector2& p_direction);
+	virtual Vector2 body_get_one_way_collision_direction(RID p_body) const;
+
+	virtual void body_set_one_way_collision_max_depth(RID p_body,float p_max_depth);
+	virtual float body_get_one_way_collision_max_depth(RID p_body) const;
+
+
 	virtual void body_set_force_integration_callback(RID p_body,Object *p_receiver,const StringName& p_method,const Variant& p_udata=Variant());
 	virtual bool body_collide_shape(RID p_body, int p_body_shape,RID p_shape, const Matrix32& p_shape_xform,const Vector2& p_motion,Vector2 *r_results,int p_result_max,int &r_result_count);
 
diff --git a/servers/physics_2d/shape_2d_sw.cpp b/servers/physics_2d/shape_2d_sw.cpp
index 336eec73b5..ed63870a12 100644
--- a/servers/physics_2d/shape_2d_sw.cpp
+++ b/servers/physics_2d/shape_2d_sw.cpp
@@ -136,6 +136,7 @@ real_t LineShape2DSW::get_moment_of_inertia(float p_mass, const Vector2 &p_scale
 	return 0;
 }
 
+
 void LineShape2DSW::set_data(const Variant& p_data) {
 
 	ERR_FAIL_COND(p_data.get_type()!=Variant::ARRAY);
diff --git a/servers/physics_2d/shape_2d_sw.h b/servers/physics_2d/shape_2d_sw.h
index 51ece9fc7e..931491efd5 100644
--- a/servers/physics_2d/shape_2d_sw.h
+++ b/servers/physics_2d/shape_2d_sw.h
@@ -85,7 +85,6 @@ public:
 
 	virtual bool intersect_segment(const Vector2& p_begin,const Vector2& p_end,Vector2 &r_point, Vector2 &r_normal) const=0;
 	virtual real_t get_moment_of_inertia(float p_mass,const Vector2& p_scale) const=0;
-
 	virtual void set_data(const Variant& p_data)=0;
 	virtual Variant get_data() const=0;
 
diff --git a/servers/physics_2d/space_2d_sw.cpp b/servers/physics_2d/space_2d_sw.cpp
index 76069de9a0..f2ed74ffbf 100644
--- a/servers/physics_2d/space_2d_sw.cpp
+++ b/servers/physics_2d/space_2d_sw.cpp
@@ -98,7 +98,7 @@ bool Physics2DDirectSpaceStateSW::intersect_ray(const Vector2& p_from, const Vec
 		if (shape->intersect_segment(local_from,local_to,shape_point,shape_normal)) {
 
 
-			//print_line("inters sgment!");
+
 			Matrix32 xform = col_obj->get_transform() * col_obj->get_shape_transform(shape_idx);
 			shape_point=xform.xform(shape_point);
 
@@ -217,6 +217,16 @@ bool Physics2DDirectSpaceStateSW::cast_motion(const RID& p_shape, const Matrix32
 		int shape_idx=space->intersection_query_subindex_results[i];
 
 
+		/*if (col_obj->get_type()==CollisionObject2DSW::TYPE_BODY) {
+
+			const Body2DSW *body=static_cast<const Body2DSW*>(col_obj);
+			if (body->get_one_way_collision_direction()!=Vector2() && p_motion.dot(body->get_one_way_collision_direction())<=CMP_EPSILON) {
+				print_line("failed in motion dir");
+				continue;
+			}
+		}*/
+
+
 		Matrix32 col_obj_xform = col_obj->get_transform() * col_obj->get_shape_transform(shape_idx);
 		//test initial overlap, does it collide if going all the way?
 		if (!CollisionSolver2DSW::solve(shape,p_xform,p_motion,col_obj->get_shape(shape_idx),col_obj_xform,Vector2() ,NULL,NULL,NULL,p_margin)) {
@@ -227,6 +237,14 @@ bool Physics2DDirectSpaceStateSW::cast_motion(const RID& p_shape, const Matrix32
 		//test initial overlap
 		if (CollisionSolver2DSW::solve(shape,p_xform,Vector2(),col_obj->get_shape(shape_idx),col_obj_xform,Vector2() ,NULL,NULL,NULL,p_margin)) {
 
+			if (col_obj->get_type()==CollisionObject2DSW::TYPE_BODY) {
+				//if one way collision direction ignore initial overlap
+				const Body2DSW *body=static_cast<const Body2DSW*>(col_obj);
+				if (body->get_one_way_collision_direction()!=Vector2()) {
+					continue;
+				}
+			}
+
 			return false;
 		}
 
@@ -253,6 +271,29 @@ bool Physics2DDirectSpaceStateSW::cast_motion(const RID& p_shape, const Matrix32
 			}
 		}
 
+		if (col_obj->get_type()==CollisionObject2DSW::TYPE_BODY) {
+
+			const Body2DSW *body=static_cast<const Body2DSW*>(col_obj);
+			if (body->get_one_way_collision_direction()!=Vector2()) {
+
+				Vector2 cd[2];
+				Physics2DServerSW::CollCbkData cbk;
+				cbk.max=1;
+				cbk.amount=0;
+				cbk.ptr=cd;
+				cbk.valid_dir=body->get_one_way_collision_direction();
+				cbk.valid_depth=body->get_one_way_collision_max_depth();
+
+				Vector2 sep=mnormal; //important optimization for this to work fast enough
+				bool collided = CollisionSolver2DSW::solve(shape,p_xform,p_motion*(hi+space->contact_max_allowed_penetration),col_obj->get_shape(shape_idx),col_obj_xform,Vector2(),Physics2DServerSW::_shape_col_cbk,&cbk,&sep,p_margin);
+				if (!collided || cbk.amount==0) {					
+					continue;
+				}
+
+			}
+		}
+
+
 		if (low<best_safe) {
 			best_safe=low;
 			best_unsafe=hi;
@@ -311,14 +352,23 @@ bool Physics2DDirectSpaceStateSW::collide_shape(RID p_shape, const Matrix32& p_s
 
 		if (p_exclude.has( col_obj->get_self() ))
 			continue;
-
+		if (col_obj->get_type()==CollisionObject2DSW::TYPE_BODY) {
+
+			const Body2DSW *body=static_cast<const Body2DSW*>(col_obj);
+			cbk.valid_dir=body->get_one_way_collision_direction();
+			cbk.valid_depth=body->get_one_way_collision_max_depth();
+		} else {
+			cbk.valid_dir=Vector2();
+			cbk.valid_depth=0;
+		}
 
 		if (CollisionSolver2DSW::solve(shape,p_shape_xform,p_motion,col_obj->get_shape(shape_idx),col_obj->get_transform() * col_obj->get_shape_transform(shape_idx),Vector2(),cbkres,cbkptr,NULL,p_margin)) {
-			collided=true;
+			collided=p_result_max==0 || cbk.amount>0;
 		}
 
 	}
 
+
 	r_result_count=cbk.amount;
 
 	return collided;
@@ -334,6 +384,8 @@ struct _RestCallbackData2D {
 	Vector2 best_contact;
 	Vector2 best_normal;
 	float best_len;
+	Vector2 valid_dir;
+	float valid_depth;
 };
 
 static void _rest_cbk_result(const Vector2& p_point_A,const Vector2& p_point_B,void *p_userdata) {
@@ -341,11 +393,23 @@ static void _rest_cbk_result(const Vector2& p_point_A,const Vector2& p_point_B,v
 
 	_RestCallbackData2D *rd=(_RestCallbackData2D*)p_userdata;
 
+	if (rd->valid_dir!=Vector2()) {
+
+		if (rd->valid_dir!=Vector2()) {
+			if (p_point_A.distance_squared_to(p_point_B)>rd->valid_depth*rd->valid_depth)
+				return;
+			if (rd->valid_dir.dot((p_point_A-p_point_B).normalized())<Math_PI*0.25)
+				return;
+		}
+
+	}
+
 	Vector2 contact_rel = p_point_B - p_point_A;
 	float len = contact_rel.length();
 	if (len <= rd->best_len)
 		return;
 
+
 	rd->best_len=len;
 	rd->best_contact=p_point_B;
 	rd->best_normal=contact_rel/len;
@@ -385,6 +449,17 @@ bool Physics2DDirectSpaceStateSW::rest_info(RID p_shape, const Matrix32& p_shape
 		if (p_exclude.has( col_obj->get_self() ))
 			continue;
 
+		if (col_obj->get_type()==CollisionObject2DSW::TYPE_BODY) {
+
+			const Body2DSW *body=static_cast<const Body2DSW*>(col_obj);
+			rcd.valid_dir=body->get_one_way_collision_direction();
+			rcd.valid_depth=body->get_one_way_collision_max_depth();
+		} else {
+			rcd.valid_dir=Vector2();
+			rcd.valid_depth=0;
+		}
+
+
 		rcd.object=col_obj;
 		rcd.shape=shape_idx;
 		bool sc = CollisionSolver2DSW::solve(shape,p_shape_xform,p_motion,col_obj->get_shape(shape_idx),col_obj->get_transform() * col_obj->get_shape_transform(shape_idx),Vector2() ,_rest_cbk_result,&rcd,NULL,p_margin);
diff --git a/servers/physics_2d_server.cpp b/servers/physics_2d_server.cpp
index 3633efc5eb..07389bc912 100644
--- a/servers/physics_2d_server.cpp
+++ b/servers/physics_2d_server.cpp
@@ -500,6 +500,13 @@ void Physics2DServer::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("body_set_max_contacts_reported","body","amount"),&Physics2DServer::body_set_max_contacts_reported);
 	ObjectTypeDB::bind_method(_MD("body_get_max_contacts_reported","body"),&Physics2DServer::body_get_max_contacts_reported);
 
+	ObjectTypeDB::bind_method(_MD("body_set_one_way_collision_direction","normal"),&Physics2DServer::body_set_one_way_collision_direction);
+	ObjectTypeDB::bind_method(_MD("body_get_one_way_collision_direction"),&Physics2DServer::body_get_one_way_collision_direction);
+
+	ObjectTypeDB::bind_method(_MD("body_set_one_way_collision_max_depth","normal"),&Physics2DServer::body_set_one_way_collision_max_depth);
+	ObjectTypeDB::bind_method(_MD("body_get_one_way_collision_max_depth"),&Physics2DServer::body_get_one_way_collision_max_depth);
+
+
 	ObjectTypeDB::bind_method(_MD("body_set_omit_force_integration","body","enable"),&Physics2DServer::body_set_omit_force_integration);
 	ObjectTypeDB::bind_method(_MD("body_is_omitting_force_integration","body"),&Physics2DServer::body_is_omitting_force_integration);
 
diff --git a/servers/physics_2d_server.h b/servers/physics_2d_server.h
index 6e53cde55c..765cebf45f 100644
--- a/servers/physics_2d_server.h
+++ b/servers/physics_2d_server.h
@@ -442,6 +442,12 @@ public:
 	virtual void body_set_max_contacts_reported(RID p_body, int p_contacts)=0;
 	virtual int body_get_max_contacts_reported(RID p_body) const=0;
 
+	virtual void body_set_one_way_collision_direction(RID p_body,const Vector2& p_direction)=0;
+	virtual Vector2 body_get_one_way_collision_direction(RID p_body) const=0;
+
+	virtual void body_set_one_way_collision_max_depth(RID p_body,float p_max_depth)=0;
+	virtual float body_get_one_way_collision_max_depth(RID p_body) const=0;
+
 	//missing remove
 	virtual void body_set_contacts_reported_depth_treshold(RID p_body, float p_treshold)=0;
 	virtual float body_get_contacts_reported_depth_treshold(RID p_body) const=0;
diff --git a/servers/visual/rasterizer.cpp b/servers/visual/rasterizer.cpp
index b5e74e0f2e..c3dcd83a31 100644
--- a/servers/visual/rasterizer.cpp
+++ b/servers/visual/rasterizer.cpp
@@ -568,8 +568,9 @@ void Rasterizer::_update_fixed_materials() {
 			}
 
 			material_set_param(fm.self,_fixed_material_uv_xform_name,fm.uv_xform);
-			if (fm.use_pointsize)
+			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());
@@ -620,6 +621,8 @@ Rasterizer::Rasterizer() {
 	_fixed_material_uv_xform_name="fmp_uv_xform";
 	_fixed_material_point_size_name="fmp_point_size";
 
+	draw_viewport_func=NULL;
+
 	ERR_FAIL_COND( sizeof(FixedMaterialShaderKey)!=4);
 
 }
diff --git a/servers/visual/rasterizer.h b/servers/visual/rasterizer.h
index 8731095425..92c7b8ac14 100644
--- a/servers/visual/rasterizer.h
+++ b/servers/visual/rasterizer.h
@@ -40,6 +40,9 @@
 class Rasterizer {
 protected:
 
+
+	typedef void (*CanvasItemDrawViewportFunc)(VisualServer*owner,void*ud,const Rect2& p_rect);
+
 	RID create_default_material();
 	RID create_overdraw_debug_material();
 
@@ -207,6 +210,8 @@ public:
 	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture)=0;
 	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const=0;
 
+	virtual Variant shader_get_default_param(RID p_shader, const StringName& p_name)=0;
+
 	/* COMMON MATERIAL API */
 
 	virtual RID material_create()=0;
@@ -561,7 +566,279 @@ public:
 		CANVAS_RECT_FLIP_H=4,
 		CANVAS_RECT_FLIP_V=8
 	};
-		
+
+	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 {
+
+			VS::MaterialBlendMode blend_mode;
+			CommandBlendMode() { type = TYPE_BLEND_MODE; blend_mode = VS::MATERIAL_BLEND_MODE_MIX; }
+		};
+		struct CommandClipIgnore : public Command {
+
+			bool ignore;
+			CommandClipIgnore() { type = TYPE_CLIP_IGNORE; ignore=false; }
+		};
+
+
+		struct ViewportRender {
+			VisualServer*owner;
+			void* udata;
+			Rect2 rect;
+		};
+
+		Matrix32 xform;
+		bool clip;
+		bool visible;
+		bool ontop;
+		VS::MaterialBlendMode blend_mode;
+		Vector<Command*> commands;
+		mutable bool custom_rect;
+		mutable bool rect_dirty;
+		mutable Rect2 rect;
+		CanvasItem*next;
+		RID shader;
+		Map<StringName,Variant> shader_param;
+		uint32_t shader_version;
+
+
+		float final_opacity;
+		Matrix32 final_transform;
+		Rect2 final_clip_rect;
+		CanvasItem* final_clip_owner;
+		CanvasItem* shader_owner;
+		ViewportRender *vp_render;
+
+		const Rect2& 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 clear() { for (int i=0;i<commands.size();i++) memdelete( commands[i] ); commands.clear(); clip=false; rect_dirty=true; final_clip_owner=NULL;  shader_owner=NULL;}
+		CanvasItem() { vp_render=NULL; next=NULL; final_clip_owner=NULL; clip=false; final_opacity=1;  blend_mode=VS::MATERIAL_BLEND_MODE_MIX; visible=true; rect_dirty=true; custom_rect=false; ontop=true; shader_version=0; shader_owner=NULL;}
+		virtual ~CanvasItem() { clear(); }
+	};
+
+
+	CanvasItemDrawViewportFunc draw_viewport_func;
+
+
 	virtual void canvas_begin()=0;
 	virtual void canvas_disable_blending()=0;
 	virtual void canvas_set_opacity(float p_opacity)=0;
@@ -575,7 +852,10 @@ public:
 	virtual void canvas_draw_primitive(const Vector<Point2>& p_points, const Vector<Color>& p_colors,const Vector<Point2>& p_uvs, RID p_texture,float p_width)=0;
 	virtual void canvas_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor)=0;
 	virtual void canvas_set_transform(const Matrix32& p_transform)=0;
-	
+
+	virtual void canvas_render_items(CanvasItem *p_item_list)=0;
+
+
 	/* ENVIRONMENT */
 	
 
diff --git a/servers/visual/rasterizer_dummy.cpp b/servers/visual/rasterizer_dummy.cpp
index a399960014..6c1b6697c1 100644
--- a/servers/visual/rasterizer_dummy.cpp
+++ b/servers/visual/rasterizer_dummy.cpp
@@ -231,6 +231,11 @@ RID RasterizerDummy::shader_get_default_texture_param(RID p_shader, const String
 	return RID();
 }
 
+Variant RasterizerDummy::shader_get_default_param(RID p_shader, const StringName& p_name) {
+
+	return Variant();
+}
+
 /* COMMON MATERIAL API */
 
 
@@ -1617,6 +1622,11 @@ void RasterizerDummy::canvas_set_transform(const Matrix32& p_transform) {
 
 }
 
+void RasterizerDummy::canvas_render_items(CanvasItem *p_item_list) {
+
+
+}
+
 /* ENVIRONMENT */
 
 RID RasterizerDummy::environment_create() {
diff --git a/servers/visual/rasterizer_dummy.h b/servers/visual/rasterizer_dummy.h
index d879fcafeb..c72149f88f 100644
--- a/servers/visual/rasterizer_dummy.h
+++ b/servers/visual/rasterizer_dummy.h
@@ -433,6 +433,8 @@ public:
 	virtual void shader_set_default_texture_param(RID p_shader, const StringName& p_name, RID p_texture);
 	virtual RID shader_get_default_texture_param(RID p_shader, const StringName& p_name) const;
 
+	virtual Variant shader_get_default_param(RID p_shader, const StringName& p_name);
+
 	/* COMMON MATERIAL API */
 
 	virtual RID material_create();
@@ -708,6 +710,8 @@ public:
 	virtual void canvas_draw_polygon(int p_vertex_count, const int* p_indices, const Vector2* p_vertices, const Vector2* p_uvs, const Color* p_colors,const RID& p_texture,bool p_singlecolor);
 	virtual void canvas_set_transform(const Matrix32& p_transform);
 
+	virtual void canvas_render_items(CanvasItem *p_item_list);
+
 	/* ENVIRONMENT */
 
 	virtual RID environment_create();
diff --git a/servers/visual/shader_language.cpp b/servers/visual/shader_language.cpp
index 40e36d2a89..dfa0172e82 100644
--- a/servers/visual/shader_language.cpp
+++ b/servers/visual/shader_language.cpp
@@ -768,16 +768,20 @@ const ShaderLanguage::IntrinsicFuncDef ShaderLanguage::intrinsic_func_defs[]={
 	//constructors
 	{"bool",TYPE_BOOL,{TYPE_BOOL,TYPE_VOID}},
 	{"float",TYPE_FLOAT,{TYPE_FLOAT,TYPE_VOID}},
+	{"vec2",TYPE_VEC2,{TYPE_FLOAT,TYPE_VOID}},
 	{"vec2",TYPE_VEC2,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
+	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_VOID}},
 	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
 	{"vec3",TYPE_VEC3,{TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
 	{"vec3",TYPE_VEC3,{TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
+	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_VEC2,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_FLOAT,TYPE_VEC2,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_FLOAT,TYPE_VEC3,TYPE_VOID}},
 	{"vec4",TYPE_VEC4,{TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
+	{"vec4",TYPE_VEC4,{TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
 	{"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
@@ -856,6 +860,9 @@ const ShaderLanguage::IntrinsicFuncDef ShaderLanguage::intrinsic_func_defs[]={
 	{"clamp",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
 	{"clamp",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
 	{"clamp",TYPE_VEC4,{TYPE_VEC4,TYPE_VEC4,TYPE_VEC4,TYPE_VOID}},
+	{"clamp",TYPE_VEC2,{TYPE_VEC2,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
+	{"clamp",TYPE_VEC3,{TYPE_VEC3,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
+	{"clamp",TYPE_VEC4,{TYPE_VEC4,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
 	{"mix",TYPE_FLOAT,{TYPE_FLOAT,TYPE_FLOAT,TYPE_FLOAT,TYPE_VOID}},
 	{"mix",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_FLOAT,TYPE_VOID}},
 	{"mix",TYPE_VEC2,{TYPE_VEC2,TYPE_VEC2,TYPE_VEC2,TYPE_VOID}},
@@ -893,6 +900,7 @@ const ShaderLanguage::IntrinsicFuncDef ShaderLanguage::intrinsic_func_defs[]={
 	{"normalize",TYPE_VEC3,{TYPE_VEC3,TYPE_VOID}},
 	{"normalize",TYPE_VEC4,{TYPE_VEC4,TYPE_VOID}},
 	{"reflect",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_VOID}},
+	{"refract",TYPE_VEC3,{TYPE_VEC3,TYPE_VEC3,TYPE_FLOAT,TYPE_VOID}},
 	//intrinsics - texture
 	{"tex",TYPE_VEC4,{TYPE_TEXTURE,TYPE_VEC2,TYPE_VOID}},
 	{"texcube",TYPE_VEC4,{TYPE_CUBEMAP,TYPE_VEC3,TYPE_VOID}},
@@ -1047,7 +1055,7 @@ const ShaderLanguage::BuiltinsDef ShaderLanguage::vertex_builtins_defs[]={
 const ShaderLanguage::BuiltinsDef ShaderLanguage::fragment_builtins_defs[]={
 
 	{ "VERTEX", TYPE_VEC3},
-	{ "POSITION", TYPE_VEC3},
+	{ "POSITION", TYPE_VEC4},
 	{ "NORMAL", TYPE_VEC3},
 	{ "TANGENT", TYPE_VEC3},
 	{ "BINORMAL", TYPE_VEC3},
@@ -1098,6 +1106,62 @@ const ShaderLanguage::BuiltinsDef ShaderLanguage::light_builtins_defs[]={
 
 };
 
+
+
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_vertex_builtins_defs[]={
+
+	{ "SRC_VERTEX", TYPE_VEC2},
+	{ "VERTEX", TYPE_VEC2},
+	{ "WORLD_VERTEX", TYPE_VEC2},
+	{ "UV", TYPE_VEC2},
+	{ "COLOR", TYPE_VEC4},
+	{ "VAR1", TYPE_VEC4},
+	{ "VAR2", TYPE_VEC4},
+	{ "POINT_SIZE", TYPE_FLOAT},
+
+	//builtins
+	{ "WORLD_MATRIX", TYPE_MAT4},
+	{ "PROJECTION_MATRIX", TYPE_MAT4},
+	{ "EXTRA_MATRIX", TYPE_MAT4},	
+	{ "TIME", TYPE_FLOAT},
+	{ NULL, TYPE_VOID},
+};
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_fragment_builtins_defs[]={
+
+	{ "SRC_COLOR", TYPE_VEC4},
+	{ "POSITION", TYPE_VEC4},
+	{ "NORMAL", TYPE_VEC3},
+	{ "UV", TYPE_VEC2},
+	{ "COLOR", TYPE_VEC4},
+	{ "TEXTURE", TYPE_TEXTURE},
+	{ "TEXTURE_PIXEL_SIZE", TYPE_VEC2},
+	{ "VAR1", TYPE_VEC4},
+	{ "VAR2", TYPE_VEC4},
+	{ "SCREEN_UV", TYPE_VEC2},
+	{ "POINT_COORD", TYPE_VEC2},
+
+//	{ "SCREEN_POS", TYPE_VEC2},
+//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT},
+	{ NULL, TYPE_VOID}
+
+};
+
+const ShaderLanguage::BuiltinsDef ShaderLanguage::ci_light_builtins_defs[]={
+
+	{ "COLOR", TYPE_VEC4},
+	{ "NORMAL", TYPE_VEC3},
+	{ "LIGHT_DIR", TYPE_VEC2},
+	{ "LIGHT_DISTANCE", TYPE_FLOAT},
+	{ "LIGHT", TYPE_VEC3},
+	{ "POINT_COORD", TYPE_VEC2},
+//	{ "SCREEN_POS", TYPE_VEC2},
+//	{ "SCREEN_TEXEL_SIZE", TYPE_VEC2},
+	{ "TIME", TYPE_FLOAT},
+	{ NULL, TYPE_VOID}
+
+};
+
 const ShaderLanguage::BuiltinsDef ShaderLanguage::postprocess_fragment_builtins_defs[]={
 
 	{ "IN_COLOR", TYPE_VEC3},
@@ -1210,9 +1274,25 @@ ShaderLanguage::Node* ShaderLanguage::validate_function_call(Parser&parser, Oper
 			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;
+				case TYPE_VEC2:
+					if (cdata.size()==1)
+						data = Vector2(cdata[0],cdata[0]);
+					else
+						data = Vector2(cdata[0],cdata[1]);
+
+					break;
+				case TYPE_VEC3:
+					if (cdata.size()==1)
+						data = Vector3(cdata[0],cdata[0],cdata[0]);
+					else
+						data = Vector3(cdata[0],cdata[1],cdata[2]);
+					break;
+				case TYPE_VEC4:
+					if (cdata.size()==1)
+						data = Plane(cdata[0],cdata[0],cdata[0],cdata[0]);
+					else
+						data = Plane(cdata[0],cdata[1],cdata[2],cdata[3]);
+					break;
 			}
 
 			cn->datatype=p_func->return_cache;
@@ -2448,6 +2528,27 @@ Error ShaderLanguage::parse(const Vector<Token>& p_tokens,ShaderType p_type,Comp
 				idx++;
 			}
 		} break;
+		case SHADER_CANVAS_ITEM_VERTEX: {
+			int idx=0;
+			while (ci_vertex_builtins_defs[idx].name) {
+				parser.program->builtin_variables[ci_vertex_builtins_defs[idx].name]=ci_vertex_builtins_defs[idx].type;
+				idx++;
+			}
+		} break;
+		case SHADER_CANVAS_ITEM_FRAGMENT: {
+			int idx=0;
+			while (ci_fragment_builtins_defs[idx].name) {
+				parser.program->builtin_variables[ci_fragment_builtins_defs[idx].name]=ci_fragment_builtins_defs[idx].type;
+				idx++;
+			}
+		} break;
+		case SHADER_CANVAS_ITEM_LIGHT: {
+			int idx=0;
+			while (ci_light_builtins_defs[idx].name) {
+				parser.program->builtin_variables[ci_light_builtins_defs[idx].name]=ci_light_builtins_defs[idx].type;
+				idx++;
+			}
+		} break;
 		case SHADER_POST_PROCESS: {
 			int idx=0;
 			while (postprocess_fragment_builtins_defs[idx].name) {
@@ -2545,6 +2646,28 @@ void ShaderLanguage::get_keyword_list(ShaderType p_type, List<String> *p_keyword
 				idx++;
 			}
 		} break;
+		case SHADER_CANVAS_ITEM_VERTEX: {
+			idx=0;
+			while (ci_vertex_builtins_defs[idx].name) {
+				p_keywords->push_back(ci_vertex_builtins_defs[idx].name);
+				idx++;
+			}
+		} break;
+		case SHADER_CANVAS_ITEM_FRAGMENT: {
+			idx=0;
+			while (ci_fragment_builtins_defs[idx].name) {
+				p_keywords->push_back(ci_fragment_builtins_defs[idx].name);
+				idx++;
+			}
+		} break;
+		case SHADER_CANVAS_ITEM_LIGHT: {
+			idx=0;
+			while (ci_light_builtins_defs[idx].name) {
+				p_keywords->push_back(ci_light_builtins_defs[idx].name);
+				idx++;
+			}
+		} break;
+
 		case SHADER_POST_PROCESS: {
 			idx=0;
 			while (postprocess_fragment_builtins_defs[idx].name) {
diff --git a/servers/visual/shader_language.h b/servers/visual/shader_language.h
index 7e01368dd5..f79c219d85 100644
--- a/servers/visual/shader_language.h
+++ b/servers/visual/shader_language.h
@@ -105,6 +105,9 @@ public:
 		SHADER_MATERIAL_VERTEX,
 		SHADER_MATERIAL_FRAGMENT,
 		SHADER_MATERIAL_LIGHT,
+		SHADER_CANVAS_ITEM_VERTEX,
+		SHADER_CANVAS_ITEM_FRAGMENT,
+		SHADER_CANVAS_ITEM_LIGHT,
 		SHADER_POST_PROCESS,
 	};
 
@@ -376,6 +379,12 @@ private:
 	static const BuiltinsDef vertex_builtins_defs[];
 	static const BuiltinsDef fragment_builtins_defs[];
 	static const BuiltinsDef light_builtins_defs[];
+
+	static const BuiltinsDef ci_vertex_builtins_defs[];
+	static const BuiltinsDef ci_fragment_builtins_defs[];
+	static const BuiltinsDef ci_light_builtins_defs[];
+
+
 	static const BuiltinsDef postprocess_fragment_builtins_defs[];
 
 	static DataType get_token_datatype(TokenType p_type);
diff --git a/servers/visual/visual_server_raster.cpp b/servers/visual/visual_server_raster.cpp
index 7cfa6dbb32..fc32702a12 100644
--- a/servers/visual/visual_server_raster.cpp
+++ b/servers/visual/visual_server_raster.cpp
@@ -3352,129 +3352,6 @@ void VisualServerRaster::canvas_item_set_clip(RID p_item, bool p_clip) {
 	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) {
 
@@ -3812,6 +3689,74 @@ void VisualServerRaster::canvas_item_add_set_blend_mode(RID p_item, MaterialBlen
 	canvas_item->commands.push_back(bm);
 };
 
+void VisualServerRaster::canvas_item_set_z(RID p_item, int p_z) {
+
+	ERR_FAIL_COND(p_z<CANVAS_ITEM_Z_MIN || p_z>CANVAS_ITEM_Z_MAX);
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	canvas_item->z=p_z;
+
+}
+
+void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	canvas_item->z_relative=p_enable;
+
+}
+
+void VisualServerRaster::canvas_item_set_use_parent_shader(RID p_item, bool p_enable) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	canvas_item->use_parent_shader=p_enable;
+
+}
+
+void VisualServerRaster::canvas_item_set_shader(RID p_item, RID p_shader) {
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND(!canvas_item);
+	canvas_item->shader=p_shader;
+}
+
+RID VisualServerRaster::canvas_item_get_shader(RID p_item) const{
+
+	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
+	ERR_FAIL_COND_V(!canvas_item,RID());
+	return canvas_item->shader;
+
+}
+
+void VisualServerRaster::canvas_item_set_shader_param(RID p_canvas_item, const StringName& p_param, const Variant& p_value){
+
+	VS_CHANGED;
+	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
+	ERR_FAIL_COND(!canvas_item);
+	if (p_value.get_type()==Variant::NIL)
+		canvas_item->shader_param.erase(p_param);
+	else
+		canvas_item->shader_param[p_param]=p_value;
+
+}
+Variant VisualServerRaster::canvas_item_get_shader_param(RID p_canvas_item, const StringName& p_param) const{
+
+	CanvasItem *canvas_item = canvas_item_owner.get( p_canvas_item );
+	ERR_FAIL_COND_V(!canvas_item,Variant());
+	if (!canvas_item->shader_param.has(p_param)) {
+		ERR_FAIL_COND_V(!canvas_item->shader.is_valid(),Variant());
+		return rasterizer->shader_get_default_param(canvas_item->shader,p_param);
+	}
+
+	return canvas_item->shader_param[p_param];
+}
+
+
 void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
@@ -3874,6 +3819,91 @@ void VisualServerRaster::canvas_item_raise(RID p_item) {
 
 }
 
+/***** CANVAS LIGHT *******/
+
+RID VisualServerRaster::canvas_light_create() {
+
+	return RID();
+}
+
+void VisualServerRaster::canvas_light_attach_to_canvas(RID p_light,RID p_canvas){
+
+
+}
+void VisualServerRaster::canvas_light_set_enabled(RID p_light, bool p_enabled){
+
+
+}
+void VisualServerRaster::canvas_light_set_transform(RID p_light, const Matrix32& p_transform){
+
+
+}
+void VisualServerRaster::canvas_light_set_texture(RID p_light, RID p_texture){
+
+
+}
+void VisualServerRaster::canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset){
+
+
+}
+void VisualServerRaster::canvas_light_set_color(RID p_light, const Color& p_color){
+
+
+}
+void VisualServerRaster::canvas_light_set_height(RID p_light, float p_height){
+
+
+}
+void VisualServerRaster::canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z){
+
+
+}
+void VisualServerRaster::canvas_light_set_item_mask(RID p_light, int p_mask){
+
+
+}
+
+void VisualServerRaster::canvas_light_set_blend_mode(RID p_light, CanvasLightBlendMode p_blend_mode){
+
+
+}
+void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_enabled){
+
+
+}
+void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size){
+
+
+}
+void VisualServerRaster::canvas_light_set_shadow_filter(RID p_light, int p_size){
+
+
+}
+
+/****** CANVAS LIGHT OCCLUDER ******/
+
+RID VisualServerRaster::canvas_light_occluder_create() {
+
+	return RID();
+}
+
+void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas) {
+
+
+}
+
+void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled){
+
+
+}
+
+void VisualServerRaster::canvas_light_occluder_set_shape(RID p_occluder,const DVector<Vector2>& p_shape){
+
+
+}
+
+
+
 /******** CANVAS *********/
 
 
@@ -6200,7 +6230,41 @@ void VisualServerRaster::_render_camera(Viewport *p_viewport,Camera *p_camera, S
 	rasterizer->end_scene();
 }
 
-void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity) {
+
+void VisualServerRaster::_render_canvas_item_tree(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect) {
+
+
+	static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
+	Rasterizer::CanvasItem *z_list[z_range];
+	Rasterizer::CanvasItem *z_last_list[z_range];
+
+	for(int i=0;i<z_range;i++) {
+		z_list[i]=NULL;
+		z_last_list[i]=NULL;
+	}
+
+
+	_render_canvas_item(p_canvas_item,p_transform,p_clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
+
+	for(int i=0;i<z_range;i++) {
+		if (!z_list[i])
+			continue;
+		rasterizer->canvas_render_items(z_list[i]);
+	}
+
+}
+
+
+void VisualServerRaster::_render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect) {
+
+	VisualServerRaster *self=(VisualServerRaster*)(p_self);
+	Viewport *vp=(Viewport*)p_vp;
+	self->_draw_viewport(vp,p_rect.pos.x,p_rect.pos.y,p_rect.size.x,p_rect.size.y);
+	self->rasterizer->canvas_begin();
+
+}
+
+void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity,int p_z,Rasterizer::CanvasItem **z_list,Rasterizer::CanvasItem **z_last_list,CanvasItem *p_canvas_clip,CanvasItem *p_shader_owner) {
 
 	CanvasItem *ci = p_canvas_item;
 
@@ -6219,24 +6283,39 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 
 	if (global_rect.intersects(p_clip_rect) && ci->viewport.is_valid() && viewport_owner.owns(ci->viewport)) {
 
-		Viewport *vp = viewport_owner.get(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();
 
+		ci->vp_render = memnew( Rasterizer::CanvasItem::ViewportRender );
+		ci->vp_render->owner=this;
+		ci->vp_render->udata=vp;
+		ci->vp_render->rect=Rect2(from.x,
+					  from.y,
+					  size.x,
+					  size.y);
+/*
 		_draw_viewport(vp,
 				from.x,
 				from.y,
 				size.x,
 				size.y);
+*/
+		//rasterizer->canvas_begin();
+	} else {
+		ci->vp_render=NULL;
+	}
 
-		rasterizer->canvas_begin();
+	if (ci->use_parent_shader && p_shader_owner)
+		ci->shader_owner=p_shader_owner;
+	else {
+		p_shader_owner=ci;
+		ci->shader_owner=NULL;
 	}
 
-	int s = ci->commands.size();
-	bool reclip=false;
 
 	float opacity = ci->opacity * p_opacity;
 
@@ -6246,8 +6325,11 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 	copymem(child_items,ci->child_items.ptr(),child_item_count*sizeof(CanvasItem*));
 
 	if (ci->clip) {
-		rasterizer->canvas_set_clip(true,global_rect);
-		canvas_clip=global_rect;
+		ci->final_clip_rect=global_rect;
+		ci->final_clip_owner=ci;
+
+	} else {
+		ci->final_clip_owner=p_canvas_clip;
 	}
 
 	if (ci->sort_y) {
@@ -6256,160 +6338,45 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 		sorter.sort(child_items,child_item_count);
 	}
 
+	if (ci->z_relative)
+		p_z=CLAMP(p_z+ci->z,CANVAS_ITEM_Z_MIN,CANVAS_ITEM_Z_MAX);
+	else
+		p_z=ci->z;
 
 	for(int i=0;i<child_item_count;i++) {
 
 		if (child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity);
+		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_shader_owner);
 	}
 
 
-	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];
+	if ((!ci->commands.empty() && p_clip_rect.intersects(global_rect)) || ci->vp_render) {
+		//something to draw?
+		ci->final_transform=xform;
+		ci->final_opacity=opacity * ci->self_opacity;
 
-			for (int i=0;i<s;i++) {
 
-				CanvasItem::Command *c=commands[i];
+		int zidx = p_z-CANVAS_ITEM_Z_MIN;
 
-				switch(c->type) {
-					case CanvasItem::Command::TYPE_LINE: {
+		if (z_last_list[zidx]) {
+			z_last_list[zidx]->next=ci;
+			z_last_list[zidx]=ci;
 
-						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();
+		} else {
+			z_list[zidx]=ci;
+			z_last_list[zidx]=ci;
 		}
-	}
-
 
-	if (reclip) {
+		ci->next=NULL;
 
-		rasterizer->canvas_set_clip(true,canvas_clip);
 	}
 
 	for(int i=0;i<child_item_count;i++) {
 
 		if (!child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity);
-	}
-
-
-	if (ci->clip) {
-		rasterizer->canvas_set_clip(false,Rect2());
-		canvas_clip=Rect2();
+		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_shader_owner);
 	}
 
 }
@@ -6419,29 +6386,61 @@ void VisualServerRaster::_render_canvas(Canvas *p_canvas,const Matrix32 &p_trans
 	rasterizer->canvas_begin();
 
 	int l = p_canvas->child_items.size();
+	Canvas::ChildItem *ci=p_canvas->child_items.ptr();
 
+	bool has_mirror=false;
 	for(int i=0;i<l;i++) {
+		if (ci[i].mirror.x || ci[i].mirror.y) {
+			has_mirror=true;
+			break;
+		}
+	}
 
-		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);
+	Rect2 clip_rect(viewport_rect.x,viewport_rect.y,viewport_rect.width,viewport_rect.height);
+	if (!has_mirror) {
 
-		//mirroring (useful for scrolling backgrounds)
-		if (ci.mirror.x!=0) {
+		static const int z_range = CANVAS_ITEM_Z_MAX-CANVAS_ITEM_Z_MIN+1;
+		Rasterizer::CanvasItem *z_list[z_range];
+		Rasterizer::CanvasItem *z_last_list[z_range];
 
-			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);
+		for(int i=0;i<z_range;i++) {
+			z_list[i]=NULL;
+			z_last_list[i]=NULL;
 		}
-		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);
+		for(int i=0;i<l;i++) {
+			_render_canvas_item(ci[i].item,p_transform,clip_rect,1.0,0,z_list,z_last_list,NULL,NULL);
 		}
-		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);
+		for(int i=0;i<z_range;i++) {
+			if (!z_list[i])
+				continue;
+			rasterizer->canvas_render_items(z_list[i]);
 		}
+	} else {
+
+		for(int i=0;i<l;i++) {
+
+			Canvas::ChildItem& ci=p_canvas->child_items[i];
+			_render_canvas_item_tree(ci.item,p_transform,clip_rect);
+
+			//mirroring (useful for scrolling backgrounds)
+			if (ci.mirror.x!=0) {
 
+				Matrix32 xform2 = p_transform * Matrix32(0,Vector2(ci.mirror.x,0));
+				_render_canvas_item_tree(ci.item,xform2,clip_rect);
+			}
+			if (ci.mirror.y!=0) {
+
+				Matrix32 xform2 = p_transform * Matrix32(0,Vector2(0,ci.mirror.y));
+				_render_canvas_item_tree(ci.item,xform2,clip_rect);
+			}
+			if (ci.mirror.y!=0 && ci.mirror.x!=0) {
+
+				Matrix32 xform2 = p_transform * Matrix32(0,ci.mirror);
+				_render_canvas_item_tree(ci.item,xform2,clip_rect);
+			}
+
+		}
 	}
 
 }
@@ -6604,7 +6603,7 @@ void VisualServerRaster::_draw_viewports() {
 			rasterizer->set_viewport(viewport_rect);
 		}
 
-		rasterizer->canvas_begin();
+		rasterizer->canvas_begin();		
 		rasterizer->canvas_disable_blending();
 		rasterizer->canvas_begin_rect(Matrix32());
 		rasterizer->canvas_draw_rect(E->get()->rt_to_screen_rect,0,Rect2(Point2(),E->get()->rt_to_screen_rect.size),E->get()->render_target_texture,Color(1,1,1));
@@ -6859,6 +6858,7 @@ RID VisualServerRaster::get_test_cube()  {
 VisualServerRaster::VisualServerRaster(Rasterizer *p_rasterizer) {
 
 	rasterizer=p_rasterizer;
+	rasterizer->draw_viewport_func=_render_canvas_item_viewport;
 	instance_update_list=NULL;
 	render_pass=0;
 	clear_color=Color(0.3,0.3,0.3,1.0);
diff --git a/servers/visual/visual_server_raster.h b/servers/visual/visual_server_raster.h
index ce52077550..57032ab441 100644
--- a/servers/visual/visual_server_raster.h
+++ b/servers/visual/visual_server_raster.h
@@ -85,6 +85,7 @@ class VisualServerRaster : public VisualServer {
 		Vector<Point2> shape;
 		Rect2 bounds;
 
+
 		Portal() { enabled=true; disable_distance=50; disable_color=Color(); connect_range=0.8; }
 	};
 
@@ -372,139 +373,32 @@ class VisualServerRaster : public VisualServer {
 
 
 
-	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 {
+	struct CanvasItem : public Rasterizer::CanvasItem {
 
-			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;
+		RID viewport;
+		int z;
+		bool z_relative;
 		bool sort_y;
 		float opacity;
 		float self_opacity;
-		MaterialBlendMode blend_mode;
-		RID viewport;
+		bool use_parent_shader;
+
 
-		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; sort_y=false;}
-		~CanvasItem() { clear(); }
+
+		CanvasItem() {
+			E=NULL;
+			z=0;
+			opacity=1;
+			self_opacity=1;
+			sort_y=false;
+			use_parent_shader=false;
+			z_relative=true;
+		}
 	};
 
 
@@ -706,7 +600,9 @@ class VisualServerRaster : public VisualServer {
 	void _process_sampled_light(const Transform &p_camera, Instance *p_sampled_light, bool p_linear_colorspace);
 
 	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);
+	static void _render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect);
+	void _render_canvas_item_tree(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect);
+	void _render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity,int p_z,Rasterizer::CanvasItem **z_list,Rasterizer::CanvasItem **z_last_list,CanvasItem *p_canvas_clip,CanvasItem *p_shader_owner);
 	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);
@@ -1217,6 +1113,51 @@ public:
 	virtual void canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend);
 	virtual void canvas_item_add_clip_ignore(RID p_item, bool p_ignore);
 	virtual void canvas_item_set_sort_children_by_y(RID p_item, bool p_enable);
+	virtual void canvas_item_set_z(RID p_item, int p_z);
+	virtual void canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable);
+
+	virtual void canvas_item_set_shader(RID p_item, RID p_shader);
+	virtual RID canvas_item_get_shader(RID p_item) const;
+
+	virtual void canvas_item_set_use_parent_shader(RID p_item, bool p_enable);
+
+
+
+	virtual void canvas_item_set_shader_param(RID p_canvas_item, const StringName& p_param, const Variant& p_value);
+	virtual Variant canvas_item_get_shader_param(RID p_canvas_item, const StringName& p_param) const;
+
+	virtual RID canvas_light_create();
+	virtual void canvas_light_attach_to_canvas(RID p_light,RID p_canvas);
+	virtual void canvas_light_set_enabled(RID p_light, bool p_enabled);
+	virtual void canvas_light_set_transform(RID p_light, const Matrix32& p_transform);
+	virtual void canvas_light_set_texture(RID p_light, RID p_texture);
+	virtual void canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset);
+	virtual void canvas_light_set_color(RID p_light, const Color& p_color);
+	virtual void canvas_light_set_height(RID p_light, float p_height);
+	virtual void canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z);
+	virtual void canvas_light_set_item_mask(RID p_light, int p_mask);
+
+	enum CanvasightBlendMode {
+		CANVAS_LIGHT_BLEND_ADD,
+		CANVAS_LIGHT_BLEND_SUB,
+		CANVAS_LIGHT_BLEND_MULTIPLY,
+		CANVAS_LIGHT_BLEND_DODGE,
+		CANVAS_LIGHT_BLEND_BURN,
+		CANVAS_LIGHT_BLEND_LIGHTEN,
+		CANVAS_LIGHT_BLEND_DARKEN,
+		CANVAS_LIGHT_BLEND_OVERLAY,
+		CANVAS_LIGHT_BLEND_SCREEN,
+	};
+	virtual void canvas_light_set_blend_mode(RID p_light, CanvasLightBlendMode p_blend_mode);
+	virtual void canvas_light_set_shadow_enabled(RID p_light, bool p_enabled);
+	virtual void canvas_light_set_shadow_buffer_size(RID p_light, int p_size);
+	virtual void canvas_light_set_shadow_filter(RID p_light, int p_size);
+
+
+	virtual RID canvas_light_occluder_create();
+	virtual void canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas);
+	virtual void canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled);
+	virtual void canvas_light_occluder_set_shape(RID p_occluder,const DVector<Vector2>& p_shape);
 
 	virtual void canvas_item_clear(RID p_item);
 	virtual void canvas_item_raise(RID p_item);
diff --git a/servers/visual/visual_server_wrap_mt.h b/servers/visual/visual_server_wrap_mt.h
index 7d2b8a3767..9574dff018 100644
--- a/servers/visual/visual_server_wrap_mt.h
+++ b/servers/visual/visual_server_wrap_mt.h
@@ -1131,10 +1131,44 @@ public:
 	FUNC2(canvas_item_add_clip_ignore,RID, bool );
 
 	FUNC2(canvas_item_set_sort_children_by_y,RID,bool);
+	FUNC2(canvas_item_set_z,RID,int);
+	FUNC2(canvas_item_set_z_as_relative_to_parent,RID,bool);
+
+	FUNC2(canvas_item_set_shader,RID, RID );
+	FUNC1RC(RID,canvas_item_get_shader,RID );
+
+	FUNC2(canvas_item_set_use_parent_shader,RID, bool );
+
+
+	FUNC3(canvas_item_set_shader_param,RID,const StringName&,const Variant&);
+	FUNC2RC(Variant,canvas_item_get_shader_param,RID,const StringName&);
 
 	FUNC1(canvas_item_clear,RID);
 	FUNC1(canvas_item_raise,RID);
 
+	/* CANVAS LIGHT */
+	FUNC0R(RID,canvas_light_create);
+	FUNC2(canvas_light_attach_to_canvas,RID,RID);
+	FUNC2(canvas_light_set_enabled,RID,bool);
+	FUNC2(canvas_light_set_transform,RID,const Matrix32&);
+	FUNC2(canvas_light_set_texture,RID,RID);
+	FUNC2(canvas_light_set_texture_offset,RID,const Vector2&);
+	FUNC2(canvas_light_set_color,RID,const Color&);
+	FUNC2(canvas_light_set_height,RID,float);
+	FUNC3(canvas_light_set_z_range,RID,int,int);
+	FUNC2(canvas_light_set_item_mask,RID,int);
+
+	FUNC2(canvas_light_set_blend_mode,RID,CanvasLightBlendMode);
+	FUNC2(canvas_light_set_shadow_enabled,RID,bool);
+	FUNC2(canvas_light_set_shadow_buffer_size,RID,int);
+	FUNC2(canvas_light_set_shadow_filter,RID,int);
+
+	/* CANVAS OCCLUDER */
+
+	FUNC0R(RID,canvas_light_occluder_create);
+	FUNC2(canvas_light_occluder_attach_to_canvas,RID,RID);
+	FUNC2(canvas_light_occluder_set_enabled,RID,bool);
+	FUNC2(canvas_light_occluder_set_shape,RID,const DVector<Vector2>&);
 
 	/* CURSOR */
 	FUNC2(cursor_set_rotation,float , int ); // radians
diff --git a/servers/visual_server.h b/servers/visual_server.h
index 4336a91407..49ae8ce4e6 100644
--- a/servers/visual_server.h
+++ b/servers/visual_server.h
@@ -86,6 +86,9 @@ public:
 		ARRAY_WEIGHTS_SIZE=4,
 		MAX_PARTICLE_COLOR_PHASES=4,
 		MAX_PARTICLE_ATTRACTORS=4,
+		CANVAS_ITEM_Z_MIN=-4096,
+		CANVAS_ITEM_Z_MAX=4096,
+
 
 
 		MAX_CURSORS = 8,
@@ -982,10 +985,53 @@ public:
 	virtual void canvas_item_add_set_blend_mode(RID p_item, MaterialBlendMode p_blend)=0;
 	virtual void canvas_item_add_clip_ignore(RID p_item, bool p_ignore)=0;
 	virtual void canvas_item_set_sort_children_by_y(RID p_item, bool p_enable)=0;
+	virtual void canvas_item_set_z(RID p_item, int p_z)=0;
+	virtual void canvas_item_set_z_as_relative_to_parent(RID p_item, bool p_enable)=0;
 
 	virtual void canvas_item_clear(RID p_item)=0;
 	virtual void canvas_item_raise(RID p_item)=0;
 
+	virtual void canvas_item_set_shader(RID p_item, RID p_shader)=0;
+	virtual RID canvas_item_get_shader(RID p_item) const=0;
+
+	virtual void canvas_item_set_use_parent_shader(RID p_item, bool p_enable)=0;
+
+	virtual void canvas_item_set_shader_param(RID p_canvas_item, const StringName& p_param, const Variant& p_value)=0;
+	virtual Variant canvas_item_get_shader_param(RID p_canvas_item, const StringName& p_param) const=0;
+
+	virtual RID canvas_light_create()=0;
+	virtual void canvas_light_attach_to_canvas(RID p_light,RID p_canvas)=0;
+	virtual void canvas_light_set_enabled(RID p_light, bool p_enabled)=0;
+	virtual void canvas_light_set_transform(RID p_light, const Matrix32& p_transform)=0;
+	virtual void canvas_light_set_texture(RID p_light, RID p_texture)=0;
+	virtual void canvas_light_set_texture_offset(RID p_light, const Vector2& p_offset)=0;
+	virtual void canvas_light_set_color(RID p_light, const Color& p_color)=0;
+	virtual void canvas_light_set_height(RID p_light, float p_height)=0;
+	virtual void canvas_light_set_z_range(RID p_light, int p_min_z,int p_max_z)=0;
+	virtual void canvas_light_set_item_mask(RID p_light, int p_mask)=0;
+
+	enum CanvasLightBlendMode {
+		CANVAS_LIGHT_BLEND_ADD,
+		CANVAS_LIGHT_BLEND_SUB,
+		CANVAS_LIGHT_BLEND_MULTIPLY,
+		CANVAS_LIGHT_BLEND_DODGE,
+		CANVAS_LIGHT_BLEND_BURN,
+		CANVAS_LIGHT_BLEND_LIGHTEN,
+		CANVAS_LIGHT_BLEND_DARKEN,
+		CANVAS_LIGHT_BLEND_OVERLAY,
+		CANVAS_LIGHT_BLEND_SCREEN,
+	};
+	virtual void canvas_light_set_blend_mode(RID p_light, CanvasLightBlendMode p_blend_mode)=0;
+	virtual void canvas_light_set_shadow_enabled(RID p_light, bool p_enabled)=0;
+	virtual void canvas_light_set_shadow_buffer_size(RID p_light, int p_size)=0;
+	virtual void canvas_light_set_shadow_filter(RID p_light, int p_size)=0;
+
+
+	virtual RID canvas_light_occluder_create()=0;
+	virtual void canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas)=0;
+	virtual void canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled)=0;
+	virtual void canvas_light_occluder_set_shape(RID p_occluder,const DVector<Vector2>& p_shape)=0;
+
 	/* CURSOR */
 	virtual void cursor_set_rotation(float p_rotation, int p_cursor = 0)=0; // radians
 	virtual void cursor_set_texture(RID p_texture, const Point2 &p_center_offset = Point2(0, 0), int p_cursor=0)=0;