From a1f715a4da71fbc2b7d6fad68624bf8b22c6da17 Mon Sep 17 00:00:00 2001
From: Juan Linietsky <reduzio@gmail.com>
Date: Mon, 2 Mar 2015 00:54:10 -0300
Subject: [PATCH] support for 2D shadow casters

Added support for 2D shadow casters.

*DANGER* Shaders in CanvasItem CHANGED, if you are using shader in a
CanvasItem and pull this, you will lose them. Shaders now work through a
2D material system similar to 3D. If you don't want to lose the 2D
shader code, save the shader as a .shd, then create a material in
CanvasItem and re-assign the shader.
---
 core/io/resource_format_binary.cpp            |  10 +
 core/io/resource_format_xml.cpp               |   5 +
 core/math/camera_matrix.cpp                   |  19 +-
 core/variant_op.cpp                           |   3 +
 demos/3d/kinematic_char/cubelib.res           | Bin 11431 -> 11530 bytes
 demos/3d/kinematic_char/level.scn             | Bin 15323 -> 15556 bytes
 drivers/SCsub                                 |   1 -
 drivers/gles2/rasterizer_gles2.cpp            | 598 +++++++++++++++++-
 drivers/gles2/rasterizer_gles2.h              |  62 +-
 drivers/gles2/shaders/SCsub                   |   1 +
 drivers/gles2/shaders/canvas.glsl             | 123 +++-
 drivers/gles2/shaders/canvas_shadow.glsl      |  62 ++
 drivers/windows/file_access_windows.cpp       |  20 +-
 modules/gdscript/gd_script.cpp                |   5 +-
 platform/android/audio_driver_opensl.cpp      |   8 +
 platform/android/os_android.cpp               |   2 +-
 platform/windows/detect.py                    |   4 +-
 scene/2d/canvas_item.cpp                      | 309 ++++++---
 scene/2d/canvas_item.h                        |  59 +-
 scene/2d/light_2d.cpp                         |  49 +-
 scene/2d/light_2d.h                           |   8 +
 scene/2d/light_occluder_2d.cpp                | 201 ++++++
 scene/2d/light_occluder_2d.h                  |  73 +++
 scene/3d/camera.cpp                           |   6 +-
 scene/3d/visual_instance.cpp                  |  15 +
 scene/3d/visual_instance.h                    |   4 +
 scene/register_scene_types.cpp                |   4 +
 scene/scene_string_names.cpp                  |   1 +
 scene/scene_string_names.h                    |   1 +
 servers/visual/rasterizer.h                   |  67 +-
 servers/visual/visual_server_raster.cpp       | 383 +++++++++--
 servers/visual/visual_server_raster.h         |  61 +-
 servers/visual/visual_server_wrap_mt.h        |  30 +-
 servers/visual_server.h                       |  33 +-
 tools/editor/editor_node.cpp                  |   2 +
 .../icons/icon_canvas_item_material.png       | Bin 0 -> 835 bytes
 tools/editor/icons/icon_canvas_modulate.png   | Bin 0 -> 441 bytes
 tools/editor/icons/icon_light_occluder_2d.png | Bin 0 -> 516 bytes
 .../editor/icons/icon_occluder_polygon_2d.png | Bin 0 -> 581 bytes
 .../collision_polygon_2d_editor_plugin.cpp    |   1 +
 .../light_occluder_2d_editor_plugin.cpp       | 500 +++++++++++++++
 .../plugins/light_occluder_2d_editor_plugin.h |  87 +++
 tools/editor/property_editor.cpp              |  40 +-
 43 files changed, 2586 insertions(+), 271 deletions(-)
 create mode 100644 drivers/gles2/shaders/canvas_shadow.glsl
 create mode 100644 scene/2d/light_occluder_2d.cpp
 create mode 100644 scene/2d/light_occluder_2d.h
 create mode 100644 tools/editor/icons/icon_canvas_item_material.png
 create mode 100644 tools/editor/icons/icon_canvas_modulate.png
 create mode 100644 tools/editor/icons/icon_light_occluder_2d.png
 create mode 100644 tools/editor/icons/icon_occluder_polygon_2d.png
 create mode 100644 tools/editor/plugins/light_occluder_2d_editor_plugin.cpp
 create mode 100644 tools/editor/plugins/light_occluder_2d_editor_plugin.h

diff --git a/core/io/resource_format_binary.cpp b/core/io/resource_format_binary.cpp
index e2371fe24f..ead6984650 100644
--- a/core/io/resource_format_binary.cpp
+++ b/core/io/resource_format_binary.cpp
@@ -1778,6 +1778,11 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path,const RES& p_
 	f->store_32(VERSION_MINOR);
 	f->store_32(FORMAT_VERSION);
 
+	if (f->get_error()!=OK && f->get_error()!=ERR_FILE_EOF) {
+		f->close();
+		return ERR_CANT_CREATE;
+	}
+
 	//f->store_32(saved_resources.size()+external_resources.size()); // load steps -not needed
 	save_unicode_string(p_resource->get_type());
 	uint64_t md_at = f->get_pos();
@@ -1910,6 +1915,11 @@ Error ResourceFormatSaverBinaryInstance::save(const String &p_path,const RES& p_
 
 	f->store_buffer((const uint8_t*)"RSRC",4); //magic at end
 
+	if (f->get_error()!=OK && f->get_error()!=ERR_FILE_EOF) {
+		f->close();
+		return ERR_CANT_CREATE;
+	}
+
 	f->close();
 
 
diff --git a/core/io/resource_format_xml.cpp b/core/io/resource_format_xml.cpp
index 75384d4ab6..033b4d5e5a 100644
--- a/core/io/resource_format_xml.cpp
+++ b/core/io/resource_format_xml.cpp
@@ -2592,6 +2592,11 @@ Error ResourceFormatSaverXMLInstance::save(const String &p_path,const RES& p_res
 	}
 
 	exit_tag("resource_file");
+	if (f->get_error()!=OK && f->get_error()!=ERR_FILE_EOF) {
+		f->close();
+		return ERR_CANT_CREATE;
+	}
+
 	f->close();
 	//memdelete(f);
 
diff --git a/core/math/camera_matrix.cpp b/core/math/camera_matrix.cpp
index a60dea7379..fbe5f8c741 100644
--- a/core/math/camera_matrix.cpp
+++ b/core/math/camera_matrix.cpp
@@ -121,7 +121,7 @@ void CameraMatrix::set_orthogonal(float p_size, float p_aspect, float p_znear, f
 
 
 void CameraMatrix::set_frustum(float p_left, float p_right, float p_bottom, float p_top, float p_near, float p_far) {
-
+#if 0
 	///@TODO, give a check to this. I'm not sure if it's working.
 	set_identity();
 
@@ -133,10 +133,27 @@ void CameraMatrix::set_frustum(float p_left, float p_right, float p_bottom, floa
 	matrix[2][3]=-(2*p_far*p_near) / (p_far-p_near);
 	matrix[3][2]=-1;
 	matrix[3][3]=0;
+#else
+	float *te = &matrix[0][0];
+	float x = 2 * p_near / ( p_right - p_left );
+	float y = 2 * p_near / ( p_top - p_bottom );
+
+	float a = ( p_right + p_left ) / ( p_right - p_left );
+	float b = ( p_top + p_bottom ) / ( p_top - p_bottom );
+	float c = - ( p_far + p_near ) / ( p_far - p_near );
+	float d = - 2 * p_far * p_near / ( p_far - p_near );
+
+	te[0] = x;	te[4] = 0;	te[8] = a;	te[12] = 0;
+	te[1] = 0;	te[5] = y;	te[9] = b;	te[13] = 0;
+	te[2] = 0;	te[6] = 0;	te[10] = c;	te[14] = d;
+	te[3] = 0;	te[7] = 0;	te[11] = - 1;	te[15] = 0;
+
+#endif
 
 }
 
 
+
 float CameraMatrix::get_z_far() const {
 	
 	const float * matrix = (const float*)this->matrix;			
diff --git a/core/variant_op.cpp b/core/variant_op.cpp
index 21bbc8c7ee..d6129e150c 100644
--- a/core/variant_op.cpp
+++ b/core/variant_op.cpp
@@ -552,6 +552,9 @@ void Variant::evaluate(const Operator& p_op, const Variant& p_a, const Variant&
 					if (p_b.type==MATRIX32) {
 						_RETURN( *p_a._data._matrix32 * *p_b._data._matrix32 );
 					};
+					if (p_b.type==VECTOR2) {
+						_RETURN( p_a._data._matrix32->xform( *(const Vector2*)p_b._data._mem) );
+					};
 					r_valid=false;
 					return;
 				} break;
diff --git a/demos/3d/kinematic_char/cubelib.res b/demos/3d/kinematic_char/cubelib.res
index 66b999d78d62d4e697f875f7eaea4891f5f4f928..27f2b9b3bdfd34b0fba38f6b600cd8735c7205f4 100644
GIT binary patch
delta 2201
zcmZ1;*%hS}6zuHG00IIG3=N?S4Byxp7}{7F7!tS`7$kTY7&tj5DycJCO!O*K7JtAX
zDVUs}lUP)gSQ(#L9A8|Np2Q%eAjMXYSd^Gstgp~A@vLfn8B1nGYD#>=Ij+*;)cC}l
zf{a848HMNv?2-x%O!-Ce3C)ZQ(hs=gSqkzq^GX!CnX6J6q#m%zv87}dCnpxAEQn!{
zeZVH`P{vVF8K0M5l$)5N@H^3H!A<6r%(OHGc}4~S1>*%mEX4(>$)$?i5155HQ*$$m
zi!<}{7(^a$)~hqer&bg^WM<$@Ni9jt%!$v<ta!kz+fd68pJ<%;`9QAYCWfL1%$f~?
z4Dku_NzDnIEXDfiIr$G+G9EJVGjJ+QWhpI-uSipP#K<71z{66KT2WG}l>UI>zQgth
z>>^C@CCLeoA25n1>`cmdz$WaV<;4GhLF^%e3WMka=G+65pEB|bE_%Qbn;69)`G6-;
zvBbg5*?%%ClN00O$sSB<{5lDoY?--<>8T8?3c^X>Cf714DMq;LTfondt8z3&bOFD@
zUdDpdWVQtY>;*-sWtpkv3@-mBA7Bzq>tZR-&ri`)^h}t-z@;#QB_}^QF-Jk3$$(+C
z!*T_N2h5^Oh72waeh{V+!%U}s2-BEh-vUvm%!X3-<kF<noXjLW1zsiw^-u)^1qO$o
z3~nx=tiFjQsYRKJCmFOS+c0a_Gq5jEc5rt%?_lr1;E?0M?I7-O%E8-#!ST-lYsa<&
z+^#bYa6243!0meY0JqbsMs~&q`v=U-PS+j8x%bvL*vY%c*?EXI+d0TP>Nto$U}a!z
zuy=E9=x6kBc93u2W^Ax`x_@A^bBP1D1A`l9gEAw7z0<1$;?8vq;*1UUuI1_u?F<YG
z+zbp4SQs9N^1GgM2zFF=w0|TS=caI=(e=E8tpfvtoC3>aeiplW22BO-1L6!?AkxX!
zL;nGbfP)Bwv(iyU1|0=WM|-Dm2N5UzbROp7{GyVF41XOYom5$J^NR{H+Ibj?6TUbw
zILJ5^G2|Zl;m~@>+(E{HnIX?3#DT*>^DzUbgMdRJM?q0$Ze~elS!%)($LkJ~PWRI*
z8nPWM9d#HS6-qWAV9{Vs<jS<Iv<Ky*blXZ+`$7;$fq@}Mf!%>wfs2tLLxG#QA?SvU
z0v8LzgTNa$2e=*B4=6XVGc+XVGcYKyGkGO8CvZE6KVar|;Adb+U|?u?z`)%g++fX+
zppedxrI0__gTtTkz~osR2CR<C3=9h<pXYFtb?9#3W?)dbuAshPHe<u)2aLgt4kiy6
zxfvOZ4=8We;atfmt?Xd`fS<wfJG)bUMQ}!9L29CgV}wHs14Gh<$sf4H*$W+RI{bAg
z+|0+F##C?1&E&)2!|db3;Pb$YSzcL8{lBJ^?tdc%v;Ss_*8i<l9RAy>y8L(6@ci$g
z<NsgYTQ~T>pI+$yAcLs?!G<yagY={S$C#!5PqoeYpXpHeUq08Z{C}ov(f<^u-2d@*
z>Hp*GQ~yU=$Nvv73H$G39Q0q@RoDB!g_7-mLs_%`I)YLL|Fxy{|Er2?{C{A+{eijt
z<{!M$jBF3hPd`w$pDf0oCd?IV8ui~xKk&b!rn_>qBC~R`<K{{H<;<*4mG3)fZ{`s$
zU}SZ?{6Lv`a=l2mB9o1(Q+By4H-omeyjMSif-*aUv>HEym@2n3`vc|Q4%(YFMc**8
zI)ODvh_9&U`;Q0!E@pWRDeeDyaz_76lq~;Ss@naxR(1UEpy3Agyq|vPf1VKI=>Op+
z@&6-D6aPmjFv};~<o?fgDE(jLR{OuqtMPxOPs{&?!0!JYVUz!NgiQJ`-yS^Se{0Z$
z|J`BJ{`ZH^{68~k<^S9B-~4~N{OkV>#ftm?3w4Fg_}>vc?SEU)l>aRO6aUxxbt*8k
zbo{UOZBy`<pKLE7!I}F%-a7q%gqi&01PO^Cz5l9Wn*WtV7*+p2;C}o-SeO?ShK34e
z|1DH)|68j${FZn9@22Jb-&;56f1qLH|8UcU|Iy~j|Klvv|0h^w{?BxfDgK}5Qt`jY
zqvn6PPt*U&XC+bs`I2pO{>NCR{tq>c{qJuOmN;L?LCy8Qg_7NWeQD$W8sfVD)x<R)
zX#D5YlQsHprfmJ+M&02zo7;a^ZLj~Hioe->^+NuK7{w%hW{S7WNc`?Fxl?kbg3@=n
zSc|m(Nj5qEQ*3kpXE+r8&vhyLU*KN#zsj%mfBohVDSjqa;nxqir6;G$>^6h=$niIu
zyN=I)AN?S;_sZXu!ns0CV*f{3B>hjc%~C99C`|azkg3|tnCs;BouOKFHTUEQ*)FId
z&ty+Cd%RcJyj4z^NkC~eQ?PMV@@`Mz$Ka5fd|lxPMBV23iaCs&@3=tW=lI`svY_%B
zUmn!N5M&(nKh-|xe}#Ab|4QGM|5g57|LcN!{x^p9{%;EH`!CcIG2wq}*u?+s5tIIR
zL{9nN9WzaVS$_Ke{-inodnf-@mgErV_+KB;{l9jyoJtZebG%LFe}~f$A5Na2qRq<?
zt;o(0sj!?OT#=h&@(GnnX^zVOInHJOvz$v5_jBa`&vmW%A7z>HK;yro^yC=T2WpIw
z-OA$Zo&W0sJN{SuIlg9SQMP7iR-Emyn4vmhIYWs8H$#!a`prpdQLMaCzY%FWZt_WO
zRn_?Z2ifTymMRYaEtKv4TY(BI2X0nNW&8h@N)F5nb`P%nKA1mQSVukAP^p4}OM#i0
zfuX_4ftkgKfq{Wpf!Tq9!B~NXfklCt#n{-`o=1V5%Qv++!zVMTD6yzAL7c%vL70Jc
z0W&M8+F>wN;9-zZU}j)aU}j)cU}i8=U_QX_Ak1L?fQg@-nSp^JC^*O&)E)r<cJTGX

delta 2039
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
bf%yQxgD`{X115fUW(Ed^px_{9P;CzYGdsvJ

diff --git a/demos/3d/kinematic_char/level.scn b/demos/3d/kinematic_char/level.scn
index a276fe22e1ae28ed1be15d9c1c2c679b4b38d355..7ccb2430c108dd188d1eec5ab066be6226dfcebb 100644
GIT binary patch
delta 7654
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
N2nr5z4hnX51^@;FpS}P9

delta 7291
zcmX?7dAnRUDA?JV0R#jX7|xY4FywMDFuY`EU{K>=U`SzSV5sF}U`SwRVA#vfz@R%(
zSA{WsW6(?{zPT&~iA9OI3eO%f&UD;7nVVUv{+>%1Yg%SSYD#=VB4cT>;x^Wtf{a84
z8HJ}0*d-G?*y9t6iV`asq#tm}GZo}#s${YjXI7;$NIhVaV@%0Z3ScZsSrFs!?Z6_Y
z%(OIx(!_fUgp`b#lS^|F8$T@&W=YM>EG~9==dyEw@Bwv(c%{Mz%=bA{QcDsubK-L|
zD<0G{>oVl2S}-N%#3u?RZa?7aSjJHFfLXIaP<gUqWKwtnCqr?v_ygwj2Tbo=cQBWh
z#aFn_O(|aTOrdANeTVH2*hQG)OOg}5KVTG3*qNmBfKAvz%kjno2C)NwQhXk8h(6%Z
zd&pq#QvHBI?|`U-o)gyt28jc)iBSxail-m&NID3bIm<s_ka4km!1~WY&_T_4?_@g`
z`T9PU7s;WF`UVMF%*mz2C8}M_iHS)`YH<%3xKm7&bzSeeTdVG4C`jO7E-pzeXgJ4E
zq;_4wm07=}vY<We0fQi8L86jP!s!FbN*@_hiyp9<GiRq(7C&H}$YA(@m5;$F$$&9F
zN!`-Dmw`>;hD#_zh)S628ixcWYYr=Y{gU$f{QML>MT-Y4@{X$-<e3XfiwabdAMmI;
zx;Ln%etE#C;%dqe+;ZBvqd{4{fjKi@FTHg&gRk0NHlNI-qQs)gq|yfrN-U{4nMryI
zybqY2UB4>`DXe8m%g<47VT@1KsAeombnteFbA8R2ldqnvpul9nFu{ROfx&_8fGCq8
zL;Vpq1qFr&%%V(23@;yWi82{8WIBX^M6{Vq81}jJgP5XBrVNiCaEUUTF{H>TXn=&Y
znavq?YAFbT*rLo94Ej1Swk1QCE{N?^`hejmlL5o}2i#)Jh776(3R(&b4_I`WjTn|1
zDF}nuV$8;x3@oNlj=}>54-nH)nB6t6EVC#-FITOJfx%&`;{`7@FXzd8Y#Pa#4*U+$
z4%QD?85kSv-6lCiJHK{dcWgZ1?X>y;w`WcRHv>bGnM1IHzT2Mz$qw-glo=eH7CMMK
zC_7y~!0i;cK$*eb`O5)rmkx(u2L`u<1Nx3n8<ZJOIJs?a;AU2Elx29pIC&16Tm5W@
z(+uhg+zsN)3XU2K4WA#dGB7vTYcf3G6?Z(}V9nfMug&m)G1#fyA>M((DeZtVgPwxG
z0d5BU2Ta^f#Rv2qf3rH}R|IDys+@ON;8f}OhJisL<p8te9R@cKE=J!(m5U6Ss`DKd
zxy*7^b#QvXAi-qJz>pB_;Kg79GNFFwfno-;1>z124CV?f2gDgH9x!n;SSoNIoXlXg
zfZHLM!CHa4;W85ggN*|70c!@^2Ta^bR~|5kD;$2nz|G{qz>t*8!0>?SmIF7VBSV8Y
z^NehE`vc4j3<}DOP7Dp=5broM9B5|paB_LTz|GuX@5<1y*<m?@+X8L}hA;+q1(pSy
z8SI@`9k|Zm`G7&3rNQ2dfgxR%fkA<rf#CrQ!vj%%CT|9Yw2KbK&i9Y0JKMKbK4p8z
z;G<x0pn<_xf!o=|fq}sf?0A0#?gQcs0SercEjaAzol@P(69f*GIf&%lVTe}HbpCWe
z!sSrb3g+VcqLPOUe;o8&*0AK}7Zqf5tzall{^`KrAmen5A@|UIhgPR32WAHu2WEym
zwcQCE?3@e?48DmashmZbi8&0c3=9lh3d~#uMVYyoC7ETZ49p6=3@i%F4w4M)3heCQ
z;;op6K~8~-fm4B*L0N%$vk2#UmdQ?{K8#+ICyKsdjG6qCPmzzq4OB{k49<S<IBBvf
zzk0o+xdVfvy92jFu)}Mo{SFL{_6PJG{SR<Ex*y<H*#Cfm+tJx+IRk^jr3cK+KJ5<T
zTzl&q?Bw0!>^wx96`YtG?9oHr86N5n7@>g<33En!4+U<A(+&&_o(e1t;;Ppf85oj7
zgVDo1Io(m(X+B#>YDGzDQEGCxSW#-RmA*cx{K!d-F9($>C8-q*J_?2h8o|-A6jyYl
zG5e+#XCw$5Dt8cJbuLXx1x1R}>jM%l=Q$EVH3TGH{yOM6o3euACH@^#A2?QyGvpq6
z;Lz&i>>zP~nK>^pH#LFBLGuyAM+aGl!gp_eG2N&t65fBks%Sq8LxcT|sv`UIRYm*1
z{jX2pW_eUqWY5qbUeB=KL3#l*%l`lW>-QfJXSlAw?;x(g|A2*ifv|&d0=EOd0&{{n
z!>tB(=KWWziW0aT#999SueWDZ5O&~p5NG-YHtb$i(f&&c%nsrV%nI@j+z#0e;t!ZN
zGd`$Fh-b9_u3+xKt)QH6n&BK+(`kmY3fv0rjP|Sw(hn?|A3KCQh$}=h*gJ$fa4Xa^
z*gs&t?eN(_T!A^^xkIo6_W^bX?E~Bj;ttXd<quf69h4VHKVa}zFrIA5B`x=mIr;(f
z^@sc*@&R-91Ll55e}{a>=mUop${F@=ek!QW#KQ1Tb@t@hJONB@yC=Wp*|S+eG?tMu
zW^$dFie0RNos%gm1A~HN97DrZ$54iN1&{~No;hQipup{5?qJVWmY7qT%8;la=p^i*
z>B#J$$&dv0g)l?%<OgCu8Ivd964$6_V0O?^U~mD2NwD*FhinH17w!Z4F470MU4##C
zEA4r}z^!m9wU~iH;o<{kW~Ds~#1r%sq#c;SDf0n?_yZ<T`G#H~;7^(wiy0Xh(&RxY
z(+j0YFm{x7sf8uYv~&ST(kwwrl-dWXL5b2W8*8Fev*rqCU|^5{wR#vBSQ#Q17#Nrp
zm>n1xA{AH|B*3gFaLK}_z|9BGtl&aGbFz)3UA+SLfjUG%2`&RbMI{TgsARAM6{q$O
zn7COS7#J8t6qvaf7#i%A(!K3-n&lPbm>cXJ84iGgNEjMK4dPt!7bNW%+@$Q%r1%x0
zm>cZT0}D}lGU$OzPjF5K6`!DbgbiGNG6*Vw3SpEIG;z~pV<`=39|Z|W!FljKgCDrS
zL@qXsA|L72Gw>=n9;#>7GcYiGG_UyqGs7d6<_Am+j~JUDurfUAZFXRIv^vh^2qZsq
z9Jz|f&(|2F6qpZ4FmNewBl7eUhI$7*r;f?{rNr!28FG)>IsI|j>EI12Um<y!!$pWG
zBe5ib+d+W?UZ^IkJIFfdF|aE{JYY(5h+|Mz5ONjXEFyh{iFf;<`)oh7+U!C^oiqP$
z{wmAD$as44FS$_T%bqMA_Z_$yxE1sr_!)Q<*!`w?7CUe=@GszJ5Kv%e5K>_F^>*N9
z5LV!J;CHb1754o<xk+9x$|2f;pFu`J*z+BOtOC0OH-o$ay92+&cNQfE1_nh1W(RKP
z*ADzFDhvz^Y6{E@svr>tb&whc4Fz@vEd^%(1P5*gZHTc9x(eJ3Iv_O;&XXk+RO-2n
z85kIh7#J8d85kHiv=|r|Kmzg#%nT+9%nWi0%nYUq%nVA9s)E5xff;Ozx&kwUwgNMQ
zxdO9;F@uEyyMwZWwgWeV?gD-Xdr%$Cpbxeq*nywHN`c?O-NE01o564aKZCUbyMsTd
zlyT^G;AcqLyhPzO6CaBL0|P@8I88GtuuPt%e3CJBa*E0_ofribr)3ZL861MS0uqz6
zQ&WPIQ}a?2!Wq&ObeysroE`if+?~W2iZj+TOqpz^`k_9-ZGn)(P3HLA{FH{33q%y>
zGZm#*CRp+&=jY@X73-&Drlpk@rzT`C5MnPbNCmaqixT#+6=x)-<d^F=uqDJdaIxv9
zBo<|-<|!H`SS=7?uZqu4ODj$-NhyE8Ak12vlV6Y;-|*2@Vu1v2YH@CSZfQ<QW<gG7
zYEj~q1(Nm5NjarOivJmli<Jx<yO;}#^0O4B81st~A1U~NTA@5nl?x0LUbyNU;Ac&&
zh)>BZR$RxB{D4KAp;#fCxg@?kH8I{*W`RCKRm1iLOI+_VggecFw*(a*CFC-sK49W^
zI>?e-nv|KJsLt%2nU|{dgf%nSDL<t$q5i2zW?n&QiGFfo0jN%l&(DibDN0OFa8)Q)
z<Y!9GFI5P2j!fWZD%Lk}Ol2%cJ;>1@^pN3y!juOLnk*$nnd#|@CJvtzw{hlVrliJ~
zXO?8>D|}LDNqrA;V)lXg32_ftq!hduGgBUL8ZstlC`B_QE8R+{OfY09R+^(&AH`gh
zo|%{Mg|#@jD6^nM>9hk|(iueo##9F9qpYAh)-z9`*RjFTpD8^xUwI}&(PPH74ALsB
z4;Vxgt#ag9;`7T=i<GxAq$bXJz#zwxoLF2Eukc5yEBny{1_@<DhEyG?1=0+~4_HlA
z^jXqV<C9Vy*17vUU^GpTU`owPseiyKrsBt%la!xWl=6Vp?E!<B@<k`32Mlg3DX9e|
z8H<d3(;qNMESbO)pP3h*n3EG<l%Jnl{D5`4auGwk^Fqdy_>>Ap2APM<JP(*8SmH}k
zE8-RBI<u<UF=psHuq0MHaB%1sXQ$?*mgMIpxiL69u{$ne2zIhbny+Z2!0A?h^N@k-
zM1~T@gUX8?xEPXks~C$C6Sx?h8@L#_6*?E^E51$RWJ=2~OT5FFm#QM-CdH7Z!0ueb
znw^?j5TEFx&rp((!kk=MROGDXbmbuPk~L1k47rN@j~S*U2s~z9>R_TcUD1raEIu(M
ztF*Wz*^N1|v?O2Ikufh`FPtG>q5dpGkpj;Godc2z4GgJ`N{YM;WiC=3S&m8xJD3ym
zGILXwF*qu4D9bbD=LIB8OGscSP~c)nQrpj<uke*QIkmXB)x>ea0|rUvl+?6Dl@$!}
zs>v*QDe)zlYEF(56t6RufI?w{Lke@TerbWyV#Ykfgxm)V_R4NbOA;PFV5k@7DlSM(
zO<~|+U|>j+$Vmn3%}p(405wxVZY{`3tYqL;;NeWoNi9n($uCkcO5o!LIjvZ~I5Q=c
zflWb{tt1)L1Y=d;WOXb`O=RF#;NU7QNK8%zr;Z{ARR%r<A-?pY#Inqi%J_o(%)Al?
zo(D{VEM@hn$qXD182J;pnNw2piWPJdx>yQ|GV_ZZcpSQzbMx~u6*^fm^U@i36^t2+
z5)}ejGn2CulX4oG7@Qrt8JHC$6>J#T71-GQ@>5ccTo{BExY)`vi!+lla}+!o_45_x
zE3h*%NIYN_V<}F}NsB)q%^>-JRhl^|H6v3|k-4Bgu_#qxzr#hIlA^@C;<WstT>XOl
z;s<PkEJgVx3<3%c4;Yo1ijxx+7CA<-mt-X7Wmo2xCfcz0BqpWiB=T|PCW5k$eoksy
zNyEzqe#N$gmkaoqi!#$Q8tN7ZuqWl0l;r0!h$`f;r{yP?7RTqMDkw20<(C#Ucrl1P
z;F6Gc2xbs_z$M-g!yx{EOL9S~qgz5MpMGX~UVc$(d~W{a4sAJ&Ev!}fc_oQCiIESO
zB>9R<ic(9GGvbR9OEU8rxD>n<BUsZ@^>Z`xCZE!lu4e(ay^=Z__}Nn{3gS~!GD{kS
z*z!yBQc_dm6I2+AleROLq*jz9_A(~sC|pl6SCDn!a$N7s#av#LSdh@eR$5SyT9llq
z@Wt_-1Gf?%Lwr({;yuS!W>C?TEW{e0l%G-=uOP>mT9mNr0TZ9Ij?*V)1(xE>{5%Gy
z4GfZu3O^jgou0BL=jY|cCo8OAD0#pk#gM0TVRD_0IHU9AX*$X=&SDJliN37)MezkW
zrAnJQ;)_cXOHzyD;~%hSIM=cUgNvdBF$Zr4dxvjK$)!cfuAr{(0da<6rL7Ffijy7o
zALMiKV}-QQRMJ>LLkuYidJa~~*C&hUDzGrHC<snA(^ao`TJ9j=z|COX(BW{)LCArb
zxhgHOD8Yl7fx*McLBJsdl(iGsnHU&M5`-O`*~&6g%M0?07H)M=b-3&r?qKS$m@y?&
zF`g+eIW<9sc|%XTql1Kl0%JwIOPYfbQ*ymW!X*b$hRO#FqRfX<#r8XBJ32YMP)KFT
z$WPDDQ*Nq%$SmV@!a<Hb6*@McwDAFpyhDP^L)XpR{9i2`xP!hpwAmkYcp$QznSr6f
z!J*n=;seIz4h#oG!IXpO1E=K=m>C}YUH-svx#KFg|A%&}zSrP%W<R{yL6#kq=}U7;
z;#J+$Haud^clyd&oRME1pROU3AbG&tDX~65QcYVW`~i!!lLu2(Uh3jdW>7QTq22w!
z6NX;KqEeMErqq%W4Vfc74&@H&4w33I>Y5Dk>S3*49okuRa}-pHRS$L8IOjUJJYcxs
zz~Er_gy#!Oa#3n(p2`;o1&6;XtPXt+XB_f)Kve~FbcaDm!Q%<T5zzRK0%(9IVU7cX
zbAkc`gM)*M1GfV+1B2=;ryUNy4hatbCdcUeaHeuMFfji4?<&4|qrL|tm&5V{++b`z
znbAnf-l_Tkw*!OAQ3nQx{sY{^Vn=6?F0b_tlN$_;nT|S6ZZwohVf*`^fq{d8fsuhh
zfsy4Oh@-&nz`*eT0TVY9GXv8D264vU{~s`NGyHkL#O=Vq!07;L=`boVAK+$S0yV#x
zK?Dnk_@$72K%e0^hzU~6@E4?G`2qdS(nfC?IT%<K*ctc~m?!g@RJyY;FcdgRD6l#(
zI9NL{H;6NOI5n^{GT1xFJKS+#aG1@&kP!TUnZY6X0W$+{gZ+`iclYmEJi+0$3xneU
zdx!ZB_Dsgc#R}6WUo?^QYiG_EYPNE4cW`E4SCD{al|)~DNLBzhGW60@7{nB09aJ5d
z9T*;P7doUmNFQK$z|QZG>G08!_kh0xzXOAVKLdlp!^yU$IxY!6`CMwmZ5%t=9gduC
zuy<JTJ#jA6*)wMn*qIp^PB=MqGyGRzaG33I`ymr6gSdi1BP&l@eojt)d3<tWZfa4Y
zBd??N<h7<6_464Q9B^oK<aG#kU}omJu55Ean30X)A)~FsLIybneg_7pUmj=JN()l*
z%kvB$D3r4~DeQ1yVCYaNXApSA;0|tdGBblJl?Mtw4jt_5+*cfbpW5SaV1q~GW5x!C
zhQuz1E6iul$T%MS<&fdP;HbmQ`{&Fa2X3YWYo-MM$#G`9ZU;bBg@A`C`|HL+Cxfq_
z938mXmK|YpFp1|nIA;MnW5a%jdS-@(Ma~KADk6?s919%U`OO&^7(zg0yFz4ssg8oP
z)3?bx%(O)3v*qQdq!u$MD0ncOQ3zEEN?>pbp8VZR*4*Xa1Ac2KK?nDP2OVo1{2h55
z>^&|yC_7GYaCS6tU_TJ-YU5zdAfQn5fZ6&1GlSz22WE$E#{-kS%_Zv%9rzhU75E*>
z9jqO)onsv89Zxv0JKH*_yMA)$XOLFVcj#x30rv(#y@z_IpAMH9<Q4cGiXHPE!Wk7A
z8j2Z|6xbb#8I-}KiUPZX{sT~+Qs8l5b~t@ty#vF6(+7kZ)D%P<)`KK86nGfa6__2Y
z9p*c1cBp4KVC^v3;r0P%22BMS$8H8K1$IY%25kj)htCW;U{Y6s-9i4KK7*bDze6yC
z{sMLeg9Ypih6~skj1<@%l^Kjdqyqz}zs_K)zyj)bILrn$>>ceNFwb^$chGl`c2IVh
z%wVQq?7;8L;;^5=VgWyc<pOpFD}{P?$7TlW1?&tq3hWM>8EhA@GuSO)ci!nBt`e2t
zuM(Fyo54we-EljEGl+CxaA<a5U~o}jabR}X?6};a-GSi&^JYhNkR1%J3NnuN3~mbS
zAg4G;J1{u4Gq@{oICwh<JLrQHdOPVqV3u|UjYxVburPQiFgw&+J2F4uwsuNBV9nsA
zpzT!7;H|*!G@Zdmf!ztzy$6wg3ha*24E_r24$Bz=6xf}*oq`?W9rrsmGXyG#J1u7j
zQebzGW(ZbbcZz2SQDAq<W(ZYacX9@0VR42q1p$ZEj?*7-uXf5mu-d`iLD@mrVX{-R
z1G7`Jqw%A9?PdpS2L=~?2L`8VhHwQAhsh529r7I*4ptxNeiU5nnEr^l*x@=iX!=AR
zGM2!=1ez@Yg#xPsGbk@IuqtpfFoAnt%nB?Fj0())!2)3hR|R%(FV9VZ*+Jcb;eazk
zqyi5^gaWgI6T^Q<pwu%&DX=i`DljudD=;(gD=;&}C@?dCx{t96%nW)8%nWe~%nsTN
z@e1q=916@V2@DLNt|3FB0yBew0y8W@B`Gi~Br*JV@OChFU^uXxK}dmz!BBzuz<LHv
z1#XAspj5@cqrmL2+ku%uM}gbnIs-UWF$mX#5|=~2L$E`=13MT8JAe|FIw({eE;}%Q
zlT^3@v%(~X{|@zFZ%jVWeIS{^OhLv$nZX>C-oYJMSc+nIxD8KGi(v_h!F~ZdqXR>O
zJcFYGyTfEqnsT@fN>lZY=?)AI;tmXsj~$p5Rz1{se!%%5^K%9+g%F3`4h#?ZpED#Y
z$T*rmlzz`(te_3@Z>j<hLy7{k!aBzPf(q;hvJXZ(+B29ah#yRT$o<}NzT@VH%<mb}
z6pS6tGo*u4PKE-z<8+2hFqx&m4(^O+D=<5DGvp}LvpZBX<bpf_s?Qu49O4=B6gU(X
zG5mLY?4a&=`2q7{$J+-MJ19G4JLEfPJLEeYcQAI~chGiVf27UsVE%}i-NE@0Gy8$f
zPRtI>3Y#8Dushs;%>4cU14DrV2SYw2uAR3#R68&@Ja<%PC{*Ba5N9Y_z|K&t!0sSk
z&rqVk?sS`>6ztM61$L*$4h#$;;Cik?ftjIPfmtDn@xPn``vc}^2kr;_(F~Oe+Ro|>
zRSN9R>I~IjvIayl)-p6OFw`}$F*4MH(jusUW?*PkU~`CPXj;I|(5%4j=+Dri!0vFG
zp%t9j+Z5Ox!uc867qByQEMRBo1SJKAE(Lan*9_eY*co~h*qx^{^eV7Bl{54$U}xx8
xV0Tbwn6QAIVWI-N!*)=#F|a9cuz^~Zpi-IBf!Fb%V<N+31%8G}lQ-H30{|IlM{@uG

diff --git a/drivers/SCsub b/drivers/SCsub
index 46334468ba..a1a2191cbc 100644
--- a/drivers/SCsub
+++ b/drivers/SCsub
@@ -10,7 +10,6 @@ SConscript('alsa/SCsub');
 SConscript('pulseaudio/SCsub');
 SConscript('windows/SCsub');
 SConscript('gles2/SCsub');
-SConscript('gles1/SCsub');
 SConscript('gl_context/SCsub');
 SConscript('openssl/SCsub');
 
diff --git a/drivers/gles2/rasterizer_gles2.cpp b/drivers/gles2/rasterizer_gles2.cpp
index aba0b5ca90..aa7bad0b8f 100644
--- a/drivers/gles2/rasterizer_gles2.cpp
+++ b/drivers/gles2/rasterizer_gles2.cpp
@@ -971,7 +971,7 @@ void RasterizerGLES2::texture_set_data(RID p_texture,const Image& p_image,VS::Cu
 
 
 
-	if ((!texture->flags&VS::TEXTURE_FLAG_VIDEO_SURFACE) && img.detect_alpha()==Image::ALPHA_BLEND) {
+	if (!(texture->flags&VS::TEXTURE_FLAG_VIDEO_SURFACE) && img.detect_alpha()==Image::ALPHA_BLEND) {
 		texture->has_alpha=true;
 	}
 
@@ -2525,7 +2525,7 @@ Error RasterizerGLES2::_surface_set_arrays(Surface *p_surface, uint8_t *p_mem,ui
 void RasterizerGLES2::mesh_add_custom_surface(RID p_mesh,const Variant& p_dat) {
 
 	ERR_EXPLAIN("OpenGL Rasterizer does not support custom surfaces. Running on wrong platform?");
-	ERR_FAIL_V();
+	ERR_FAIL();
 }
 
 Array RasterizerGLES2::mesh_get_surface_arrays(RID p_mesh,int p_surface) const {
@@ -4116,6 +4116,10 @@ void RasterizerGLES2::begin_frame() {
 	shadow_filter=ShadowFilterTechnique(int(Globals::get_singleton()->get("rasterizer/shadow_filter")));
 #endif
 
+	canvas_shader.set_conditional(CanvasShaderGLES2::SHADOW_PCF5,shadow_filter==SHADOW_FILTER_PCF5);
+	canvas_shader.set_conditional(CanvasShaderGLES2::SHADOW_PCF13,shadow_filter==SHADOW_FILTER_PCF13);
+	canvas_shader.set_conditional(CanvasShaderGLES2::SHADOW_ESM,shadow_filter==SHADOW_FILTER_ESM);
+
 	window_size = Size2( OS::get_singleton()->get_video_mode().width, OS::get_singleton()->get_video_mode().height );
 
 	double time = (OS::get_singleton()->get_ticks_usec()/1000); // get msec
@@ -7874,7 +7878,8 @@ void RasterizerGLES2::canvas_begin() {
 	canvas_blend_mode=VS::MATERIAL_BLEND_MODE_MIX;
 	canvas_texscreen_used=false;
 	uses_texpixel_size=false;
-	canvas_last_shader=RID();
+
+	canvas_last_material=NULL;
 
 }
 
@@ -8364,6 +8369,476 @@ void RasterizerGLES2::canvas_set_transform(const Matrix32& p_transform) {
 	//canvas_transform = Variant(p_transform);
 }
 
+RID RasterizerGLES2::canvas_light_occluder_create() {
+
+	CanvasOccluder *co = memnew( CanvasOccluder );
+	co->index_id=0;
+	co->vertex_id=0;
+	co->len=0;
+
+	return canvas_occluder_owner.make_rid(co);
+}
+
+void RasterizerGLES2::canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines) {
+
+	CanvasOccluder *co = canvas_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!co);
+
+	co->lines=p_lines;
+
+	if (p_lines.size()!=co->len) {
+
+		if (co->index_id)
+			glDeleteBuffers(1,&co->index_id);
+		if (co->vertex_id)
+			glDeleteBuffers(1,&co->vertex_id);
+
+		co->index_id=0;
+		co->vertex_id=0;
+		co->len=0;
+
+	}
+
+	if (p_lines.size()) {
+
+
+
+		DVector<float> geometry;
+		DVector<uint16_t> indices;
+		int lc = p_lines.size();
+
+		geometry.resize(lc*6);
+		indices.resize(lc*3);
+
+		DVector<float>::Write vw=geometry.write();
+		DVector<uint16_t>::Write iw=indices.write();
+
+
+		DVector<Vector2>::Read lr=p_lines.read();
+
+		const int POLY_HEIGHT = 16384;
+
+		for(int i=0;i<lc/2;i++) {
+
+			vw[i*12+0]=lr[i*2+0].x;
+			vw[i*12+1]=lr[i*2+0].y;
+			vw[i*12+2]=POLY_HEIGHT;
+
+			vw[i*12+3]=lr[i*2+1].x;
+			vw[i*12+4]=lr[i*2+1].y;
+			vw[i*12+5]=POLY_HEIGHT;
+
+			vw[i*12+6]=lr[i*2+1].x;
+			vw[i*12+7]=lr[i*2+1].y;
+			vw[i*12+8]=-POLY_HEIGHT;
+
+			vw[i*12+9]=lr[i*2+0].x;
+			vw[i*12+10]=lr[i*2+0].y;
+			vw[i*12+11]=-POLY_HEIGHT;
+
+			iw[i*6+0]=i*4+0;
+			iw[i*6+1]=i*4+1;
+			iw[i*6+2]=i*4+2;
+
+			iw[i*6+3]=i*4+2;
+			iw[i*6+4]=i*4+3;
+			iw[i*6+5]=i*4+0;
+
+		}
+
+		//if same buffer len is being set, just use BufferSubData to avoid a pipeline flush
+
+
+		if (!co->vertex_id) {
+			glGenBuffers(1,&co->vertex_id);
+			glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
+			glBufferData(GL_ARRAY_BUFFER,lc*6*sizeof(real_t),vw.ptr(),GL_STATIC_DRAW);
+		} else {
+
+			glBindBuffer(GL_ARRAY_BUFFER,co->vertex_id);
+			glBufferSubData(GL_ARRAY_BUFFER,0,lc*6*sizeof(real_t),vw.ptr());
+
+		}
+
+		glBindBuffer(GL_ARRAY_BUFFER,0); //unbind
+
+		if (!co->index_id) {
+
+			glGenBuffers(1,&co->index_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
+			glBufferData(GL_ELEMENT_ARRAY_BUFFER,lc*3*sizeof(uint16_t),iw.ptr(),GL_STATIC_DRAW);
+		} else {
+
+
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,co->index_id);
+			glBufferSubData(GL_ELEMENT_ARRAY_BUFFER,0,lc*3*sizeof(uint16_t),iw.ptr());
+		}
+
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0); //unbind
+
+		co->len=lc;
+
+	}
+
+
+
+}
+
+RID RasterizerGLES2::canvas_light_shadow_buffer_create(int p_width) {
+
+	CanvasLightShadow *cls = memnew( CanvasLightShadow );
+	if (p_width>max_texture_size)
+		p_width=max_texture_size;
+
+	cls->size=p_width;
+	glActiveTexture(GL_TEXTURE0);
+
+	glGenFramebuffers(1, &cls->fbo);
+	glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
+
+	// Create a render buffer
+	glGenRenderbuffers(1, &cls->rbo);
+	glBindRenderbuffer(GL_RENDERBUFFER, cls->rbo);
+
+	// Create a texture for storing the depth
+	glGenTextures(1, &cls->depth);
+	glBindTexture(GL_TEXTURE_2D, cls->depth);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+
+	// Remove artifact on the edges of the shadowmap
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+
+	cls->height=16;
+
+	//print_line("ERROR? "+itos(glGetError()));
+	if ( read_depth_supported ) {
+
+		// We'll use a depth texture to store the depths in the shadow map
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, cls->size, cls->height, 0,
+			     GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
+
+#ifdef GLEW_ENABLED
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+#endif
+
+		// Attach the depth texture to FBO depth attachment point
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+				       GL_TEXTURE_2D, cls->depth, 0);
+
+#ifdef GLEW_ENABLED
+		glDrawBuffer(GL_NONE);
+#endif
+	} else {
+		// We'll use a RGBA texture into which we pack the depth info
+		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, cls->size, cls->height, 0,
+			     GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+		// Attach the RGBA texture to FBO color attachment point
+		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0,
+				       GL_TEXTURE_2D, cls->depth, 0);
+
+		// Allocate 16-bit depth buffer
+		glRenderbufferStorage(GL_RENDERBUFFER, GL_DEPTH_COMPONENT16, cls->size, cls->height);
+
+		// Attach the render buffer as depth buffer - will be ignored
+		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT,
+					  GL_RENDERBUFFER, cls->rbo);
+
+
+	}
+
+	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+	//printf("errnum: %x\n",status);
+#ifdef GLEW_ENABLED
+	if (read_depth_supported) {
+		glDrawBuffer(GL_BACK);
+	}
+#endif
+	glBindFramebuffer(GL_FRAMEBUFFER, base_framebuffer);
+	DEBUG_TEST_ERROR("2D Shadow Buffer Init");
+	ERR_FAIL_COND_V( status != GL_FRAMEBUFFER_COMPLETE, RID() );
+
+#ifdef GLEW_ENABLED
+	if (read_depth_supported) {
+		glDrawBuffer(GL_BACK);
+	}
+#endif
+
+	return canvas_light_shadow_owner.make_rid(cls);
+}
+
+void RasterizerGLES2::canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache) {
+
+	CanvasLightShadow *cls = canvas_light_shadow_owner.get(p_buffer);
+	ERR_FAIL_COND(!cls);
+
+
+	glDisable(GL_BLEND);
+	glDisable(GL_SCISSOR_TEST);
+	glDisable(GL_DITHER);
+	glDisable(GL_CULL_FACE);
+	glDepthFunc(GL_LEQUAL);
+	glEnable(GL_DEPTH_TEST);
+	glDepthMask(true);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
+
+	if (!use_rgba_shadowmaps)
+		glColorMask(0, 0, 0, 0);
+
+	glEnableVertexAttribArray(VS::ARRAY_VERTEX);
+	canvas_shadow_shader.bind();
+
+	const int vp_height = 10;
+
+	glViewport(0, 0, cls->size,cls->height);
+	_glClearDepth(1.0f);
+	glClearColor(1,1,1,1);
+	glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
+
+	VS::CanvasOccluderPolygonCullMode cull=VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED;
+
+
+	for(int i=0;i<4;i++) {
+
+		//make sure it remains orthogonal, makes easy to read angle later
+
+		Transform light;
+		light.origin[0]=p_light_xform[2][0];
+		light.origin[1]=p_light_xform[2][1];
+		light.basis[0][0]=p_light_xform[0][0];
+		light.basis[0][1]=p_light_xform[1][0];
+		light.basis[1][0]=p_light_xform[0][1];
+		light.basis[1][1]=p_light_xform[1][1];
+
+		//light.basis.scale(Vector3(to_light.elements[0].length(),to_light.elements[1].length(),1));
+
+	///	p_near=1;
+		CameraMatrix projection;
+		{
+			real_t fov =  90;
+			real_t near = p_near;
+			real_t far = p_far;
+			real_t aspect = 1.0;
+
+			real_t ymax = near * Math::tan( Math::deg2rad( fov * 0.5 ) );
+			real_t ymin = - ymax;
+			real_t xmin = ymin * aspect;
+			real_t xmax = ymax * aspect;
+
+			projection.set_frustum( xmin, xmax, ymin, ymax, near, far );
+		}
+
+		Vector3 cam_target=Matrix3(Vector3(0,0,Math_PI*2*(i/4.0))).xform(Vector3(0,1,0));
+		projection = projection * CameraMatrix(Transform().looking_at(cam_target,Vector3(0,0,-1)).affine_inverse());
+
+		//print_line("near: "+rtos(p_near));
+		//print_line("far: "+rtos(p_far));
+		//projection.set_perspective(60,size/float(vp_height),p_near,p_far);
+
+	//	CameraMatrix light_mat = projection * CameraMatrix(camera);
+
+		canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES2::PROJECTION_MATRIX,projection);
+		canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES2::LIGHT_MATRIX,light);
+
+		if (i==0)
+			*p_xform_cache=projection;
+
+		glViewport(0, (cls->height/4)*i, cls->size,cls->height/4);
+
+		CanvasLightOccluderInstance *instance=p_occluders;
+
+		while(instance) {
+
+			CanvasOccluder *cc = canvas_occluder_owner.get(instance->polygon_buffer);
+			if (!cc || cc->len==0 || !(p_light_mask&instance->light_mask)) {
+
+				instance=instance->next;
+				continue;
+			}
+
+			canvas_shadow_shader.set_uniform(CanvasShadowShaderGLES2::WORLD_MATRIX,instance->xform_cache);
+			if (cull!=instance->cull_cache) {
+
+				cull=instance->cull_cache;
+				switch(cull) {
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED: {
+
+						glDisable(GL_CULL_FACE);
+
+					} break;
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE: {
+
+						glEnable(GL_CULL_FACE);
+						glCullFace(GL_FRONT);
+					} break;
+					case VS::CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE: {
+
+						glEnable(GL_CULL_FACE);
+						glCullFace(GL_BACK);
+
+					} break;
+				}
+			}
+/*
+			if (i==0) {
+				for(int i=0;i<cc->lines.size();i++) {
+					Vector2 p = instance->xform_cache.xform(cc->lines.get(i));
+					Plane pp(Vector3(p.x,p.y,0),1);
+					pp.normal = light.xform(pp.normal);
+					pp = projection.xform4(pp);
+					print_line(itos(i)+": "+pp.normal/pp.d);
+					//pp=light_mat.xform4(pp);
+					//print_line(itos(i)+": "+pp.normal/pp.d);
+				}
+			}
+*/
+			glBindBuffer(GL_ARRAY_BUFFER,cc->vertex_id);
+			glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,cc->index_id);
+			glVertexAttribPointer(VS::ARRAY_VERTEX, 3, GL_FLOAT, false, 0, 0);
+			glDrawElements(GL_TRIANGLES,cc->len*3,GL_UNSIGNED_SHORT,0);
+
+
+			instance=instance->next;
+		}
+
+
+	}
+
+	glDisableVertexAttribArray(VS::ARRAY_VERTEX);
+	glBindBuffer(GL_ARRAY_BUFFER,0);
+	glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
+
+	if (shadow_filter==SHADOW_FILTER_ESM) {
+		//blur the buffer
+#if 0
+	//this is ignord, it did not make any difference..
+		if (read_depth_supported) {
+			glDepthFunc(GL_ALWAYS);
+		} else {
+			glDisable(GL_DEPTH_TEST);
+			glDepthMask(false);
+		}
+		glDisable(GL_CULL_FACE);
+		glViewport(0, 0, cls->size,cls->height);
+
+		int passes=1;
+		CanvasLightShadow *blur = canvas_light_shadow_owner.get(canvas_shadow_blur);
+
+		copy_shader.set_conditional(CopyShaderGLES2::SHADOW_BLUR_H_PASS,true);
+		copy_shader.bind();
+		copy_shader.set_uniform(CopyShaderGLES2::PIXEL_SCALE,1);
+		copy_shader.set_uniform(CopyShaderGLES2::BLUR_MAGNITUDE,1);
+		glUniform1i(copy_shader.get_uniform_location(CopyShaderGLES2::SOURCE),0);
+
+		for(int i=0;i<passes;i++) {
+
+			glBindFramebuffer(GL_FRAMEBUFFER, blur->fbo);
+			glActiveTexture(GL_TEXTURE0);
+
+			if (read_depth_supported)
+				glBindTexture(GL_TEXTURE_2D,cls->depth);
+			else
+				glBindTexture(GL_TEXTURE_2D,cls->rgba);
+
+
+			{
+				Vector2 src_sb_uv[4]={
+					Vector2( 0, 1),
+					Vector2( 1, 1),
+					Vector2( 1, 0),
+					Vector2( 0, 0)
+				};
+				static const Vector2 dst_pos[4]={
+					Vector2(-1, 1),
+					Vector2( 1, 1),
+					Vector2( 1,-1),
+					Vector2(-1,-1)
+				};
+
+
+
+				copy_shader.set_uniform(CopyShaderGLES2::PIXEL_SIZE,Vector2(1.0,1.0)/cls->size);
+				_draw_gui_primitive(4,dst_pos,NULL,src_sb_uv);
+			}
+
+			glActiveTexture(GL_TEXTURE0);
+			if (read_depth_supported)
+				glBindTexture(GL_TEXTURE_2D,blur->depth);
+			else
+				glBindTexture(GL_TEXTURE_2D,blur->rgba);
+
+			glBindFramebuffer(GL_FRAMEBUFFER, cls->fbo);
+
+			{
+				float hlimit = float(cls->size) / blur->size;
+				//hlimit*=2.0;
+				Vector2 src_sb_uv[4]={
+					Vector2( 0, 1),
+					Vector2( hlimit, 1),
+					Vector2( hlimit, 0),
+					Vector2( 0, 0)
+				};
+				static const Vector2 dst_pos[4]={
+					Vector2(-1, 1),
+					Vector2( 1, 1),
+					Vector2( 1,-1),
+					Vector2(-1,-1)
+				};
+
+
+				copy_shader.set_uniform(CopyShaderGLES2::PIXEL_SIZE,Vector2(1.0,1.0)/blur->size);
+				_draw_gui_primitive(4,dst_pos,NULL,src_sb_uv);
+			}
+
+		}
+		copy_shader.set_conditional(CopyShaderGLES2::SHADOW_BLUR_H_PASS,false);
+		glDepthFunc(GL_LEQUAL);
+#endif
+	}
+
+	glBindFramebuffer(GL_FRAMEBUFFER, current_rt?current_rt->fbo:base_framebuffer);
+	glColorMask(1, 1, 1, 1);
+
+
+
+}
+
+
+void RasterizerGLES2::canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow) {
+
+	CanvasLight* light=p_lights_with_shadow;
+
+	canvas_begin(); //reset
+
+	int h = 10;
+	int w = viewport.width;
+	int ofs = h;
+	while(light) {
+
+		if (light->shadow_buffer.is_valid()) {
+
+			CanvasLightShadow * sb = canvas_light_shadow_owner.get(light->shadow_buffer);
+			if (sb) {
+				glActiveTexture(GL_TEXTURE0);
+				if (read_depth_supported)
+					glBindTexture(GL_TEXTURE_2D,sb->depth);
+				else
+					glBindTexture(GL_TEXTURE_2D,sb->rgba);
+				_draw_textured_quad(Rect2(h,ofs,w-h*2,h),Rect2(0,0,sb->size,10),Size2(sb->size,10),false,false);
+				ofs+=h*2;
+
+			}
+		}
+
+		light=light->shadows_next_ptr;
+	}
+
+}
+
 void RasterizerGLES2::_canvas_normal_set_flip(const Vector2& p_flip) {
 
 	if (p_flip==normal_flip)
@@ -8508,14 +8983,14 @@ void RasterizerGLES2::_canvas_item_render_commands(CanvasItem *p_item,CanvasItem
 
 }
 
-void RasterizerGLES2::_canvas_item_setup_shader_params(CanvasItem *shader_owner,Shader* shader) {
+void RasterizerGLES2::_canvas_item_setup_shader_params(CanvasItemMaterial *material,Shader* shader) {
 
 	if (canvas_shader.bind())
 		rebind_texpixel_size=true;
 
-	if (shader_owner->shader_version!=shader->version) {
+	if (material->shader_version!=shader->version) {
 		//todo optimize uniforms
-		shader_owner->shader_version=shader->version;
+		material->shader_version=shader->version;
 	}
 
 	if (shader->has_texscreen && framebuffer.active) {
@@ -8558,14 +9033,14 @@ void RasterizerGLES2::_canvas_item_setup_shader_params(CanvasItem *shader_owner,
 
 }
 
-void RasterizerGLES2::_canvas_item_setup_shader_uniforms(CanvasItem *shader_owner,Shader* shader) {
+void RasterizerGLES2::_canvas_item_setup_shader_uniforms(CanvasItemMaterial *material,Shader* shader) {
 
 	//this can be optimized..
 	int tex_id=1;
 	int idx=0;
 	for(Map<StringName,ShaderLanguage::Uniform>::Element *E=shader->uniforms.front();E;E=E->next()) {
 
-		Map<StringName,Variant>::Element *F=shader_owner->shader_param.find(E->key());
+		Map<StringName,Variant>::Element *F=material->shader_param.find(E->key());
 
 		if ((E->get().type==ShaderLanguage::TYPE_TEXTURE || E->get().type==ShaderLanguage::TYPE_CUBEMAP)) {
 
@@ -8623,6 +9098,8 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 	canvas_modulate=p_modulate;
 	canvas_shader.set_conditional(CanvasShaderGLES2::USE_MODULATE,canvas_use_modulate);
 
+	bool reset_modulate=false;
+
 	while(p_item_list) {
 
 		CanvasItem *ci=p_item_list;
@@ -8632,12 +9109,13 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 				draw_viewport_func(ci->vp_render->owner,ci->vp_render->udata,ci->vp_render->rect);
 			}
 			memdelete(ci->vp_render);
-			ci->vp_render=NULL;
-			canvas_last_shader=RID();
+			ci->vp_render=NULL;			
+			canvas_last_material=NULL;
 			canvas_use_modulate=p_modulate!=Color(1,1,1,1);
 			canvas_modulate=p_modulate;
 			canvas_shader.set_conditional(CanvasShaderGLES2::USE_MODULATE,canvas_use_modulate);
 			rebind_shader=true;
+			reset_modulate=true;
 
 
 		}
@@ -8660,13 +9138,14 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 
 
 		//begin rect
-		CanvasItem *shader_owner = ci->shader_owner?ci->shader_owner:ci;
+		CanvasItem *material_owner = ci->material_owner?ci->material_owner:ci;
+		CanvasItemMaterial *material = material_owner->material;
 
-		if (shader_owner->shader!=canvas_last_shader || rebind_shader) {
+		if (material!=canvas_last_material || rebind_shader) {
 
 			Shader *shader = NULL;
-			if (shader_owner->shader.is_valid()) {
-				shader = this->shader_owner.get(shader_owner->shader);
+			if (material && material->shader.is_valid()) {
+				shader = shader_owner.get(material->shader);
 				if (shader && !shader->valid) {
 					shader=NULL;
 				}
@@ -8676,7 +9155,7 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 
 			if (shader) {
 				canvas_shader.set_custom_shader(shader->custom_code_id);
-				_canvas_item_setup_shader_params(shader_owner,shader);
+				_canvas_item_setup_shader_params(material,shader);
 			} else {
 				shader_cache=NULL;
 				canvas_shader.set_custom_shader(0);
@@ -8688,16 +9167,26 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 
 			canvas_shader.set_uniform(CanvasShaderGLES2::PROJECTION_MATRIX,canvas_transform);
 			if (canvas_use_modulate)
-				canvas_shader.set_uniform(CanvasShaderGLES2::MODULATE,canvas_modulate);
-			canvas_last_shader=shader_owner->shader;
+				reset_modulate=true;
+			canvas_last_material=material;
 			rebind_shader=false;
 		}
 
-		if (shader_cache) {
+		if (material && shader_cache) {
 
-			_canvas_item_setup_shader_uniforms(shader_owner,shader_cache);
+			_canvas_item_setup_shader_uniforms(material,shader_cache);
 		}
 
+		if (material && material->unshaded) {
+			canvas_shader.set_uniform(CanvasShaderGLES2::MODULATE,Color(1,1,1,1));
+			reset_modulate=true;
+		} else if (reset_modulate) {
+			canvas_shader.set_uniform(CanvasShaderGLES2::MODULATE,canvas_modulate);
+			reset_modulate=false;
+		}
+
+
+
 		canvas_shader.set_uniform(CanvasShaderGLES2::MODELVIEW_MATRIX,ci->final_transform);
 		canvas_shader.set_uniform(CanvasShaderGLES2::EXTRA_MATRIX,Matrix32());
 
@@ -8747,7 +9236,7 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 
 		_canvas_item_render_commands<false>(ci,current_clip,reclip);
 
-		if (canvas_blend_mode==VS::MATERIAL_BLEND_MODE_MIX && p_light) {
+		if (canvas_blend_mode==VS::MATERIAL_BLEND_MODE_MIX && p_light && (!material || !material->unshaded)) {
 
 			CanvasLight *light = p_light;
 			bool light_used=false;
@@ -8785,13 +9274,15 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 						normal_flip=Vector2(1,1);
 
 					}
+					canvas_shader.set_conditional(CanvasShaderGLES2::USE_SHADOWS,light->shadow_buffer.is_valid());
+
 					bool light_rebind = canvas_shader.bind();
 
 					if (light_rebind) {
 
-						if (shader_owner && shader_cache) {
-							_canvas_item_setup_shader_params(shader_owner,shader_cache);
-							_canvas_item_setup_shader_uniforms(shader_owner,shader_cache);
+						if (material && shader_cache) {
+							_canvas_item_setup_shader_params(material,shader_cache);
+							_canvas_item_setup_shader_uniforms(material,shader_cache);
 						}
 
 						canvas_shader.set_uniform(CanvasShaderGLES2::MODELVIEW_MATRIX,ci->final_transform);
@@ -8800,6 +9291,7 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 						if (canvas_use_modulate)
 							canvas_shader.set_uniform(CanvasShaderGLES2::MODULATE,canvas_modulate);
 						canvas_shader.set_uniform(CanvasShaderGLES2::NORMAL_FLIP,Vector2(1,1));
+						canvas_shader.set_uniform(CanvasShaderGLES2::SHADOWPIXEL_SIZE,1.0/light->shadow_buffer_size);
 
 
 					}
@@ -8808,6 +9300,23 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 					canvas_shader.set_uniform(CanvasShaderGLES2::LIGHT_POS,light->light_shader_pos);
 					canvas_shader.set_uniform(CanvasShaderGLES2::LIGHT_COLOR,light->color);
 					canvas_shader.set_uniform(CanvasShaderGLES2::LIGHT_HEIGHT,light->height);
+					if (light->shadow_buffer.is_valid()) {
+
+						CanvasLightShadow *cls = canvas_light_shadow_owner.get(light->shadow_buffer);
+						glActiveTexture(GL_TEXTURE0+max_texture_units-3);
+						if (read_depth_supported)
+							glBindTexture(GL_TEXTURE_2D,cls->depth);
+						else
+							glBindTexture(GL_TEXTURE_2D,cls->rgba);
+
+						canvas_shader.set_uniform(CanvasShaderGLES2::SHADOW_TEXTURE,max_texture_units-3);
+						canvas_shader.set_uniform(CanvasShaderGLES2::SHADOW_MATRIX,light->shadow_matrix_cache);
+						canvas_shader.set_uniform(CanvasShaderGLES2::LIGHT_LOCAL_MATRIX,light->xform_cache.affine_inverse());
+						canvas_shader.set_uniform(CanvasShaderGLES2::SHADOW_ESM_MULTIPLIER,light->shadow_esm_mult);
+
+					}
+
+
 					glActiveTexture(GL_TEXTURE0+max_texture_units-2);
 					canvas_shader.set_uniform(CanvasShaderGLES2::LIGHT_TEXTURE,max_texture_units-2);
 					Texture *t = texture_owner.get(light->texture);
@@ -8831,12 +9340,13 @@ void RasterizerGLES2::canvas_render_items(CanvasItem *p_item_list,int p_z,const
 
 				canvas_shader.set_conditional(CanvasShaderGLES2::USE_LIGHTING,false);
 				canvas_shader.set_conditional(CanvasShaderGLES2::USE_MODULATE,canvas_use_modulate);
+				canvas_shader.set_conditional(CanvasShaderGLES2::USE_SHADOWS,false);
 
 				canvas_shader.bind();
 
-				if (shader_owner && shader_cache) {
-					_canvas_item_setup_shader_params(shader_owner,shader_cache);
-					_canvas_item_setup_shader_uniforms(shader_owner,shader_cache);
+				if (material && shader_cache) {
+					_canvas_item_setup_shader_params(material,shader_cache);
+					_canvas_item_setup_shader_uniforms(material,shader_cache);
 				}
 
 				canvas_shader.set_uniform(CanvasShaderGLES2::MODELVIEW_MATRIX,ci->final_transform);
@@ -9067,6 +9577,11 @@ bool RasterizerGLES2::is_environment(const RID& p_rid) const {
 }
 bool RasterizerGLES2::is_shader(const RID& p_rid) const {
 
+	return shader_owner.owns(p_rid);
+}
+
+bool RasterizerGLES2::is_canvas_light_occluder(const RID& p_rid) const {
+
 	return false;
 }
 
@@ -9244,7 +9759,30 @@ void RasterizerGLES2::free(const RID& p_rid) {
 		glDeleteTextures(1,&sampled_light->texture);
 		sampled_light_owner.free(p_rid);
 		memdelete( sampled_light );
+	} else if (canvas_occluder_owner.owns(p_rid)) {
 
+
+		CanvasOccluder *co = canvas_occluder_owner.get(p_rid);
+		if (co->index_id)
+			glDeleteBuffers(1,&co->index_id);
+		if (co->vertex_id)
+			glDeleteBuffers(1,&co->vertex_id);
+
+		canvas_occluder_owner.free(p_rid);
+		memdelete(co);
+
+	} else if (canvas_light_shadow_owner.owns(p_rid)) {
+
+		CanvasLightShadow *cls = canvas_light_shadow_owner.get(p_rid);
+		glDeleteFramebuffers(1,&cls->fbo);
+		glDeleteRenderbuffers(1,&cls->rbo);
+		glDeleteTextures(1,&cls->depth);
+		if (!read_depth_supported) {
+			glDeleteTextures(1,&cls->rgba);
+		}
+
+		canvas_light_shadow_owner.free(p_rid);
+		memdelete(cls);
 	};
 }
 
@@ -9779,10 +10317,12 @@ void RasterizerGLES2::init() {
 	material_shader.init();
 	canvas_shader.init();
 	copy_shader.init();
+	canvas_shadow_shader.init();
 
 #ifdef GLEW_ENABLED
 	material_shader.set_conditional(MaterialShaderGLES2::USE_GLES_OVER_GL,true);
 	canvas_shader.set_conditional(CanvasShaderGLES2::USE_GLES_OVER_GL,true);
+	canvas_shadow_shader.set_conditional(CanvasShadowShaderGLES2::USE_GLES_OVER_GL,true);
 	copy_shader.set_conditional(CopyShaderGLES2::USE_GLES_OVER_GL,true);
 #endif
 
@@ -9923,8 +10463,11 @@ void RasterizerGLES2::init() {
 
 
 	glGetIntegerv(GL_MAX_TEXTURE_IMAGE_UNITS, &max_texture_units);
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE,&max_texture_size);
 	//read_depth_supported=false;
 
+	canvas_shadow_blur = canvas_light_shadow_buffer_create(max_texture_size);
+
 	{
 		//shadowmaps
 		OS::VideoMode vm=OS::get_singleton()->get_video_mode();
@@ -9946,6 +10489,7 @@ void RasterizerGLES2::init() {
 
 		//material_shader
 		material_shader.set_conditional(MaterialShaderGLES2::USE_DEPTH_SHADOWS,!use_rgba_shadowmaps);
+		canvas_shadow_shader.set_conditional(CanvasShadowShaderGLES2::USE_DEPTH_SHADOWS,!use_rgba_shadowmaps);
 
 	}
 
@@ -9978,7 +10522,7 @@ void RasterizerGLES2::init() {
 
 void RasterizerGLES2::finish() {
 
-
+	free(canvas_shadow_blur);
 }
 
 int RasterizerGLES2::get_render_info(VS::RenderInfo p_info) {
diff --git a/drivers/gles2/rasterizer_gles2.h b/drivers/gles2/rasterizer_gles2.h
index 173ca14180..f09714f50c 100644
--- a/drivers/gles2/rasterizer_gles2.h
+++ b/drivers/gles2/rasterizer_gles2.h
@@ -51,6 +51,7 @@
 
 #include "drivers/gles2/shaders/material.glsl.h"
 #include "drivers/gles2/shaders/canvas.glsl.h"
+#include "drivers/gles2/shaders/canvas_shadow.glsl.h"
 #include "drivers/gles2/shaders/blur.glsl.h"
 #include "drivers/gles2/shaders/copy.glsl.h"
 #include "drivers/gles2/shader_compiler_gles2.h"
@@ -816,6 +817,7 @@ class RasterizerGLES2 : public Rasterizer {
 	bool current_depth_mask;
 	VS::MaterialBlendMode current_blend_mode;
 	bool use_fast_texture_filter;
+	int max_texture_size;
 
 	bool fragment_lighting;
 	RID shadow_material;
@@ -1160,6 +1162,7 @@ class RasterizerGLES2 : public Rasterizer {
 	void _process_glow_and_bloom();
 	//void _update_blur_buffer();
 
+
 	/*********/
 	/* FRAME */
 	/*********/
@@ -1178,6 +1181,45 @@ class RasterizerGLES2 : public Rasterizer {
 	} _rinfo;
 
 
+	/*******************/
+	/* CANVAS OCCLUDER */
+	/*******************/
+
+
+	struct CanvasOccluder {
+
+		GLuint vertex_id; // 0 means, unconfigured
+		GLuint index_id; // 0 means, unconfigured
+		DVector<Vector2> lines;
+		int len;
+	};
+
+	RID_Owner<CanvasOccluder> canvas_occluder_owner;
+
+	/***********************/
+	/* CANVAS LIGHT SHADOW */
+	/***********************/
+
+
+	struct CanvasLightShadow {
+
+		int size;
+		int height;
+		GLuint fbo;
+		GLuint rbo;
+		GLuint depth;
+		GLuint rgba; //for older devices
+
+		GLuint blur;
+
+	};
+
+	RID_Owner<CanvasLightShadow> canvas_light_shadow_owner;
+
+	RID canvas_shadow_blur;
+
+	/* ETC */
+
 	RenderTarget *current_rt;
 	bool current_rt_transparent;
 	bool current_rt_vflip;
@@ -1192,7 +1234,7 @@ class RasterizerGLES2 : public Rasterizer {
 	bool uses_texpixel_size;
 	bool rebind_texpixel_size;
 	Transform canvas_transform;
-	RID canvas_last_shader;
+	CanvasItemMaterial *canvas_last_material;
 	bool canvas_texscreen_used;
 	Vector2 normal_flip;
 	_FORCE_INLINE_ void _canvas_normal_set_flip(const Vector2& p_flip);
@@ -1227,10 +1269,12 @@ class RasterizerGLES2 : public Rasterizer {
 	VS::ScenarioDebugMode current_debug;
 	RID overdraw_material;
 
+
 	mutable MaterialShaderGLES2 material_shader;
 	mutable CanvasShaderGLES2 canvas_shader;
 	BlurShaderGLES2 blur_shader;
 	CopyShaderGLES2 copy_shader;
+	mutable CanvasShadowShaderGLES2 canvas_shadow_shader;
 
 	mutable ShaderCompilerGLES2 shader_precompiler;
 
@@ -1254,8 +1298,8 @@ class RasterizerGLES2 : public Rasterizer {
 
 	template<bool use_normalmap>
 	_FORCE_INLINE_ void _canvas_item_render_commands(CanvasItem *p_item,CanvasItem *current_clip,bool &reclip);
-	_FORCE_INLINE_ void _canvas_item_setup_shader_params(CanvasItem *shader_owner,Shader* p_shader);
-	_FORCE_INLINE_ void _canvas_item_setup_shader_uniforms(CanvasItem *shader_owner,Shader* p_shader);
+	_FORCE_INLINE_ void _canvas_item_setup_shader_params(CanvasItemMaterial *material,Shader* p_shader);
+	_FORCE_INLINE_ void _canvas_item_setup_shader_uniforms(CanvasItemMaterial *material,Shader* p_shader);
 public:
 
 	/* TEXTURE API */
@@ -1572,7 +1616,17 @@ public:
 	virtual void canvas_set_transform(const Matrix32& p_transform);
 
 	virtual void canvas_render_items(CanvasItem *p_item_list,int p_z,const Color& p_modulate,CanvasLight *p_light);
+	virtual void canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow);
 
+	/* CANVAS LIGHT SHADOW */
+
+	//buffer
+	virtual RID canvas_light_shadow_buffer_create(int p_width);
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache);
+
+	//occluder
+	virtual RID canvas_light_occluder_create();
+	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines);
 
 	/* ENVIRONMENT */
 
@@ -1611,6 +1665,8 @@ public:
 	virtual bool is_environment(const RID& p_rid) const;
 	virtual bool is_shader(const RID& p_rid) const;
 
+	virtual bool is_canvas_light_occluder(const RID& p_rid) const;
+
 	virtual void free(const RID& p_rid);
 
 	virtual void init();
diff --git a/drivers/gles2/shaders/SCsub b/drivers/gles2/shaders/SCsub
index c665cf9036..9679223b16 100644
--- a/drivers/gles2/shaders/SCsub
+++ b/drivers/gles2/shaders/SCsub
@@ -3,6 +3,7 @@ Import('env')
 if env['BUILDERS'].has_key('GLSL120GLES'):
 	env.GLSL120GLES('material.glsl');
 	env.GLSL120GLES('canvas.glsl');
+	env.GLSL120GLES('canvas_shadow.glsl');
 	env.GLSL120GLES('blur.glsl');
 	env.GLSL120GLES('copy.glsl');
 
diff --git a/drivers/gles2/shaders/canvas.glsl b/drivers/gles2/shaders/canvas.glsl
index 227a8b7bdd..9022f30d7f 100644
--- a/drivers/gles2/shaders/canvas.glsl
+++ b/drivers/gles2/shaders/canvas.glsl
@@ -34,6 +34,10 @@ varying vec4 local_rot;
 uniform vec2 normal_flip;
 #endif
 
+#ifdef USE_SHADOWS
+highp varying vec2 pos;
+#endif
+
 #endif
 
 #if defined(ENABLE_VAR1_INTERP)
@@ -63,6 +67,8 @@ VERTEX_SHADER_CODE
         outvec = modelview_matrix * outvec;
 #endif
 
+
+
 #ifdef USE_PIXEL_SNAP
 
 	outvec.xy=floor(outvec.xy+0.5);
@@ -75,6 +81,9 @@ VERTEX_SHADER_CODE
 
 	light_uv_interp.xy = (light_matrix * outvec).xy;
 	light_uv_interp.zw = outvec.xy-light_pos;
+#ifdef USE_SHADOWS
+	pos=outvec.xy;
+#endif
 
 #if defined(NORMAL_USED)
 	local_rot.xy=normalize( (modelview_matrix * ( extra_matrix * vec4(1.0,0.0,0.0,0.0) )).xy  )*normal_flip.x;
@@ -154,6 +163,15 @@ varying vec4 local_rot;
 uniform sampler2D shadow_texture;
 uniform float shadow_attenuation;
 
+uniform highp mat4 shadow_matrix;
+uniform highp mat4 light_local_matrix;
+highp varying vec2 pos;
+uniform float shadowpixel_size;
+
+#ifdef SHADOW_ESM
+uniform float shadow_esm_multiplier;
+#endif
+
 #endif
 
 #endif
@@ -173,10 +191,6 @@ void main() {
 	vec3 normal = vec3(0,0,1);
 #endif
 
-#ifdef USE_MODULATE
-
-	color*=modulate;
-#endif
 
 	color *= texture2D( texture,  uv_interp );
 #if defined(ENABLE_SCREEN_UV)
@@ -191,6 +205,12 @@ FRAGMENT_SHADER_CODE
 	color = vec4(vec3(enc32),1.0);
 #endif
 
+#ifdef USE_MODULATE
+
+	color*=modulate;
+#endif
+
+
 #ifdef USE_LIGHTING
 
 #if defined(NORMAL_USED)
@@ -201,13 +221,96 @@ FRAGMENT_SHADER_CODE
 
 	vec4 light = texture2D(light_texture,light_uv_interp.xy) * light_color;
 #ifdef USE_SHADOWS
-	//this might not be that great on mobile?
-	float light_dist = length(light_texture.zw);
-	float light_angle = atan2(light_texture.x,light_texture.z) + 1.0 * 0.5;
-	float shadow_dist = texture2D(shadow_texture,vec2(light_angle,0));
-	if (light_dist>shadow_dist) {
-		light*=shadow_attenuation;
+
+
+	vec2 lpos = (light_local_matrix * vec4(pos,0.0,1.0)).xy;
+	float angle_to_light = -atan(lpos.x,lpos.y);
+	float PI = 3.14159265358979323846264;
+	/*int i = int(mod(floor((angle_to_light+7.0*PI/6.0)/(4.0*PI/6.0))+1.0, 3.0)); // +1 pq os indices estao em ordem 2,0,1 nos arrays
+	float ang*/
+
+	float su,sz;
+
+	float abs_angle = abs(angle_to_light);
+	vec2 point;
+	float sh;
+	if (abs_angle<45.0*PI/180.0) {
+		point = lpos;
+		sh=0+(1.0/8.0);
+	} else if (abs_angle>135.0*PI/180.0) {
+		point = -lpos;
+		sh = 0.5+(1.0/8.0);
+	} else if (angle_to_light>0) {
+
+		point = vec2(lpos.y,-lpos.x);
+		sh = 0.25+(1.0/8.0);
+	} else {
+
+		point = vec2(-lpos.y,lpos.x);
+		sh = 0.75+(1.0/8.0);
+
 	}
+
+
+	vec4 s = shadow_matrix * vec4(point,0.0,1.0);
+	s.xyz/=s.w;
+	su=s.x*0.5+0.5;
+	sz=s.z*0.5+0.5;
+
+	float shadow_attenuation;
+
+#ifdef SHADOW_PCF5
+
+	shadow_attenuation=0.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*2.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*2.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation/=5.0;
+
+#endif
+
+#ifdef SHADOW_PCF13
+
+	shadow_attenuation += texture2D(shadow_texture,vec2(su,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*2.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*3.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*4.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*5.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su+shadowpixel_size*6.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*2.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*3.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*4.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*5.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation += texture2D(shadow_texture,vec2(su-shadowpixel_size*6.0,sh)).z<sz?0.0:1.0;
+	shadow_attenuation/=13.0;
+
+#endif
+
+#ifdef SHADOW_ESM
+
+
+	{
+		float unnormalized = su/shadowpixel_size;
+		float fractional = fract(unnormalized);
+		unnormalized = floor(unnormalized);
+		float zc = texture2D(shadow_texture,vec2((unnormalized-0.5)*shadowpixel_size,sh)).z;
+		float zn = texture2D(shadow_texture,vec2((unnormalized+0.5)*shadowpixel_size,sh)).z;
+		float z = mix(zc,zn,fractional);
+		shadow_attenuation=clamp(exp(shadow_esm_multiplier* ( z - sz )),0.0,1.0);
+	}
+
+#endif
+
+#if !defined(SHADOW_PCF5) && !defined(SHADOW_PCF13) && !defined(SHADOW_ESM)
+
+	shadow_attenuation = texture2D(shadow_texture,vec2(su+shadowpixel_size,sh)).z<sz?0.0:1.0;
+
+#endif
+
+	light*=shadow_attenuation;
 //use shadows
 #endif
 
diff --git a/drivers/gles2/shaders/canvas_shadow.glsl b/drivers/gles2/shaders/canvas_shadow.glsl
new file mode 100644
index 0000000000..40cf321dce
--- /dev/null
+++ b/drivers/gles2/shaders/canvas_shadow.glsl
@@ -0,0 +1,62 @@
+[vertex]
+
+#ifdef USE_GLES_OVER_GL
+#define mediump
+#define highp
+#else
+precision mediump float;
+precision mediump int;
+#endif
+
+uniform highp mat4 projection_matrix;
+uniform highp mat4 light_matrix;
+uniform highp mat4 world_matrix;
+
+attribute highp vec3 vertex; // attrib:0
+
+#ifndef USE_DEPTH_SHADOWS
+
+varying vec4 position_interp;
+
+#endif
+
+
+void main() {
+
+	gl_Position = projection_matrix * (light_matrix * (world_matrix *  vec4(vertex,1.0)));
+
+#ifndef USE_DEPTH_SHADOWS
+	position_interp = gl_Position;
+#endif
+
+}
+
+[fragment]
+
+#ifdef USE_GLES_OVER_GL
+#define mediump
+#define highp
+#else
+precision mediump float;
+precision mediump int;
+#endif
+
+#ifndef USE_DEPTH_SHADOWS
+
+varying vec4 position_interp;
+
+#endif
+
+void main() {
+
+#ifdef USE_DEPTH_SHADOWS
+
+#else
+	highp float depth = ((position_interp.z / position_interp.w) + 1.0) * 0.5 + 0.0;//bias;
+	highp vec4 comp = fract(depth * vec4(256.0 * 256.0 * 256.0, 256.0 * 256.0, 256.0, 1.0));
+	comp -= comp.xxyz * vec4(0, 1.0 / 256.0, 1.0 / 256.0, 1.0 / 256.0);
+	gl_FragColor = comp;
+#endif
+
+}
+
diff --git a/drivers/windows/file_access_windows.cpp b/drivers/windows/file_access_windows.cpp
index a6073cbb29..e24685432c 100644
--- a/drivers/windows/file_access_windows.cpp
+++ b/drivers/windows/file_access_windows.cpp
@@ -28,14 +28,18 @@
 /*************************************************************************/
 #ifdef WINDOWS_ENABLED
 
+#include <Windows.h>
+#include "Shlwapi.h"
 #include "file_access_windows.h"
 
+
 #include <sys/types.h>
 #include <sys/stat.h>
 #include <wchar.h>
 #include <tchar.h>
 #include "print_string.h"
 
+
 #ifdef _MSC_VER
  #define S_ISREG(m) ((m)&_S_IFREG)
 #endif
@@ -111,10 +115,20 @@ void FileAccessWindows::close() {
 
 		//unlink(save_path.utf8().get_data());
 		//print_line("renaming..");
-		_wunlink(save_path.c_str()); //unlink if exists
-		int rename_error = _wrename((save_path+".tmp").c_str(),save_path.c_str());
+		//_wunlink(save_path.c_str()); //unlink if exists
+		//int rename_error = _wrename((save_path+".tmp").c_str(),save_path.c_str());
+
+
+		bool rename_error;
+		if (!PathFileExistsW(save_path.c_str())) {
+			//creating new file
+			rename_error = _wrename((save_path+".tmp").c_str(),save_path.c_str())!=0;
+		} else {
+			//atomic replace for existing file
+			rename_error = !ReplaceFileW(save_path.c_str(), (save_path+".tmp").c_str(), NULL, 2|4, NULL, NULL);
+		}
 		save_path="";
-		ERR_FAIL_COND( rename_error != 0);
+		ERR_FAIL_COND( rename_error );
 	}
 
 
diff --git a/modules/gdscript/gd_script.cpp b/modules/gdscript/gd_script.cpp
index 0aa115ffbc..d3a9abf4b7 100644
--- a/modules/gdscript/gd_script.cpp
+++ b/modules/gdscript/gd_script.cpp
@@ -2696,7 +2696,10 @@ Error ResourceFormatSaverGDScript::save(const String &p_path,const RES& p_resour
 	}
 
 	file->store_string(source);
-
+	if (file->get_error()!=OK && file->get_error()!=ERR_FILE_EOF) {
+		memdelete(file);
+		return ERR_CANT_CREATE;
+	}
 	file->close();
 	memdelete(file);
 	return OK;
diff --git a/platform/android/audio_driver_opensl.cpp b/platform/android/audio_driver_opensl.cpp
index 857d1a4a54..4c0c095e10 100644
--- a/platform/android/audio_driver_opensl.cpp
+++ b/platform/android/audio_driver_opensl.cpp
@@ -396,6 +396,14 @@ void AudioDriverOpenSL::finish(){
 void AudioDriverOpenSL::set_pause(bool p_pause) {
 
 	pause=p_pause;
+
+	if (active) {
+		if (pause) {
+			(*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PAUSED);
+		} else {
+			(*playItf)->SetPlayState(playItf, SL_PLAYSTATE_PLAYING);
+		}
+	}
 }
 
 
diff --git a/platform/android/os_android.cpp b/platform/android/os_android.cpp
index 6f1c03b593..6b91c01dfc 100644
--- a/platform/android/os_android.cpp
+++ b/platform/android/os_android.cpp
@@ -151,7 +151,7 @@ void OS_Android::initialize(const VideoMode& p_desired,int p_video_driver,int p_
 	sample_manager = memnew( SampleManagerMallocSW );
 	audio_server = memnew( AudioServerSW(sample_manager) );
 
-	audio_server->set_mixer_params(AudioMixerSW::INTERPOLATION_LINEAR,false);
+	audio_server->set_mixer_params(AudioMixerSW::INTERPOLATION_LINEAR,true);
 	audio_server->init();
 
 	spatial_sound_server = memnew( SpatialSoundServerSW );
diff --git a/platform/windows/detect.py b/platform/windows/detect.py
index 16dd695c59..62bab00f7b 100644
--- a/platform/windows/detect.py
+++ b/platform/windows/detect.py
@@ -115,7 +115,7 @@ def configure(env):
 		env.Append(CCFLAGS=['/DGLES2_ENABLED'])
 
 		env.Append(CCFLAGS=['/DGLEW_ENABLED'])
-		LIBS=['winmm','opengl32','dsound','kernel32','ole32','user32','gdi32', 'IPHLPAPI', 'wsock32', 'shell32','advapi32']
+		LIBS=['winmm','opengl32','dsound','kernel32','ole32','user32','gdi32', 'IPHLPAPI','Shlwapi', 'wsock32', 'shell32','advapi32']
 		env.Append(LINKFLAGS=[p+env["LIBSUFFIX"] for p in LIBS])
 		
 		env.Append(LIBPATH=[os.getenv("WindowsSdkDir")+"/Lib"])
@@ -229,7 +229,7 @@ def configure(env):
 		env.Append(CCFLAGS=['-DWINDOWS_ENABLED','-mwindows'])
 		env.Append(CPPFLAGS=['-DRTAUDIO_ENABLED'])
 		env.Append(CCFLAGS=['-DGLES2_ENABLED','-DGLEW_ENABLED'])
-		env.Append(LIBS=['mingw32','opengl32', 'dsound', 'ole32', 'd3d9','winmm','gdi32','iphlpapi','wsock32','kernel32'])
+		env.Append(LIBS=['mingw32','opengl32', 'dsound', 'ole32', 'd3d9','winmm','gdi32','iphlpapi','shlwapi','wsock32','kernel32'])
 
 		if (env["bits"]=="32" and env["mingw64_for_32"]!="yes"):
 #			env.Append(LIBS=['gcc_s'])
diff --git a/scene/2d/canvas_item.cpp b/scene/2d/canvas_item.cpp
index 223adaf9bb..4a1842100a 100644
--- a/scene/2d/canvas_item.cpp
+++ b/scene/2d/canvas_item.cpp
@@ -36,6 +36,192 @@
 #include "scene/resources/texture.h"
 #include "scene/resources/style_box.h"
 
+
+bool CanvasItemMaterial::_set(const StringName& p_name, const Variant& p_value) {
+
+	if (p_name==SceneStringNames::get_singleton()->shader_shader) {
+		set_shader(p_value);
+		return true;
+	} else if (p_name==SceneStringNames::get_singleton()->shader_unshaded) {
+		set_unshaded(p_value);
+		print_line("set unshaded");
+		return true;
+	} else {
+
+		if (shader.is_valid()) {
+
+
+			StringName pr = shader->remap_param(p_name);
+			if (!pr) {
+				String n = p_name;
+				if (n.find("param/")==0) { //backwards compatibility
+					pr = n.substr(6,n.length());
+				}
+			}
+			if (pr) {
+				VisualServer::get_singleton()->canvas_item_material_set_shader_param(material,pr,p_value);
+				return true;
+			}
+		}
+	}
+
+	return false;
+}
+
+bool CanvasItemMaterial::_get(const StringName& p_name,Variant &r_ret) const {
+
+
+	if (p_name==SceneStringNames::get_singleton()->shader_shader) {
+
+		r_ret=get_shader();
+		return true;
+	} else if (p_name==SceneStringNames::get_singleton()->shader_unshaded) {
+
+
+		r_ret=unshaded;
+		return true;
+	} else {
+
+		if (shader.is_valid()) {
+
+			StringName pr = shader->remap_param(p_name);
+			if (pr) {
+				r_ret=VisualServer::get_singleton()->canvas_item_material_get_shader_param(material,pr);
+				return true;
+			}
+		}
+
+	}
+
+
+	return false;
+}
+
+
+void CanvasItemMaterial::_get_property_list( List<PropertyInfo> *p_list) const {
+
+	p_list->push_back( PropertyInfo( Variant::OBJECT, "shader/shader", PROPERTY_HINT_RESOURCE_TYPE,"CanvasItemShader,CanvasItemShaderGraph" ) );
+	p_list->push_back( PropertyInfo( Variant::BOOL, "shader/unshaded") );
+
+	if (!shader.is_null()) {
+
+		shader->get_param_list(p_list);
+	}
+
+}
+
+void CanvasItemMaterial::set_shader(const Ref<Shader>& p_shader) {
+
+	ERR_FAIL_COND(p_shader.is_valid() && p_shader->get_mode()!=Shader::MODE_CANVAS_ITEM);
+#ifdef TOOLS_ENABLED
+
+	if (shader.is_valid()) {
+		shader->disconnect("changed",this,"_shader_changed");
+	}
+#endif
+	shader=p_shader;
+
+#ifdef TOOLS_ENABLED
+
+	if (shader.is_valid()) {
+		shader->connect("changed",this,"_shader_changed");
+	}
+#endif
+
+	RID rid;
+	if (shader.is_valid())
+		rid=shader->get_rid();
+
+	VS::get_singleton()->canvas_item_material_set_shader(material,rid);
+	_change_notify(); //properties for shader exposed
+	emit_changed();
+}
+
+Ref<Shader> CanvasItemMaterial::get_shader() const{
+
+	return shader;
+}
+
+void CanvasItemMaterial::set_shader_param(const StringName& p_param,const Variant& p_value){
+
+	VS::get_singleton()->canvas_item_material_set_shader_param(material,p_param,p_value);
+}
+
+Variant CanvasItemMaterial::get_shader_param(const StringName& p_param) const{
+
+	return VS::get_singleton()->canvas_item_material_get_shader_param(material,p_param);
+}
+
+void CanvasItemMaterial::_shader_changed() {
+
+
+}
+
+RID CanvasItemMaterial::get_rid() const {
+
+	return material;
+}
+
+void CanvasItemMaterial::set_unshaded(bool p_unshaded) {
+
+	unshaded=p_unshaded;
+	VS::get_singleton()->canvas_item_material_set_unshaded(material,p_unshaded);
+}
+
+bool CanvasItemMaterial::is_unshaded() const{
+
+	return unshaded;
+}
+
+void CanvasItemMaterial::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_shader","shader:Shader"),&CanvasItemMaterial::set_shader);
+	ObjectTypeDB::bind_method(_MD("get_shader:Shader"),&CanvasItemMaterial::get_shader);
+	ObjectTypeDB::bind_method(_MD("set_shader_param","param","value"),&CanvasItemMaterial::set_shader_param);
+	ObjectTypeDB::bind_method(_MD("get_shader_param","param"),&CanvasItemMaterial::get_shader_param);
+	ObjectTypeDB::bind_method(_MD("set_unshaded","unshaded"),&CanvasItemMaterial::set_unshaded);
+	ObjectTypeDB::bind_method(_MD("is_unshaded"),&CanvasItemMaterial::is_unshaded);
+
+}
+
+void CanvasItemMaterial::get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const {
+
+	String f = p_function.operator String();
+	if ((f=="get_shader_param" || f=="set_shader_param") && p_idx==0) {
+
+		if (shader.is_valid()) {
+			List<PropertyInfo> pl;
+			shader->get_param_list(&pl);
+			for (List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
+				r_options->push_back("\""+E->get().name.replace_first("shader_param/","")+"\"");
+			}
+		}
+	}
+	Resource::get_argument_options(p_function,p_idx,r_options);
+}
+
+CanvasItemMaterial::CanvasItemMaterial() {
+
+	material=VS::get_singleton()->canvas_item_material_create();
+	unshaded=false;
+}
+
+CanvasItemMaterial::~CanvasItemMaterial(){
+
+	VS::get_singleton()->free(material);
+}
+
+
+
+
+
+
+
+
+///////////////////////////////////////////////////////////////////
+
+
+
 bool CanvasItem::is_visible() const {
 
 	if (!is_inside_tree())
@@ -730,111 +916,35 @@ bool CanvasItem::is_draw_behind_parent_enabled() const{
 	return behind;
 }
 
-void CanvasItem::set_shader(const Ref<Shader>& p_shader) {
+void CanvasItem::set_material(const Ref<CanvasItemMaterial>& p_material) {
 
-	ERR_FAIL_COND(p_shader.is_valid() && p_shader->get_mode()!=Shader::MODE_CANVAS_ITEM);
-
-#ifdef TOOLS_ENABLED
-
-	if (shader.is_valid()) {
-		shader->disconnect("changed",this,"_shader_changed");
-	}
-#endif
-	shader=p_shader;
-
-#ifdef TOOLS_ENABLED
-
-	if (shader.is_valid()) {
-		shader->connect("changed",this,"_shader_changed");
-	}
-#endif
 
+	material=p_material;
 	RID rid;
-	if (shader.is_valid())
-		rid=shader->get_rid();
-	VS::get_singleton()->canvas_item_set_shader(canvas_item,rid);
-	_change_notify(); //properties for shader exposed
+	if (material.is_valid())
+		rid=material->get_rid();
+	VS::get_singleton()->canvas_item_set_material(canvas_item,rid);
+	_change_notify(); //properties for material exposed
 }
 
-void CanvasItem::set_use_parent_shader(bool p_use_parent_shader) {
+void CanvasItem::set_use_parent_material(bool p_use_parent_material) {
 
-	use_parent_shader=p_use_parent_shader;
-	VS::get_singleton()->canvas_item_set_use_parent_shader(canvas_item,p_use_parent_shader);
+	use_parent_material=p_use_parent_material;
+	VS::get_singleton()->canvas_item_set_use_parent_material(canvas_item,p_use_parent_material);
 }
 
-bool CanvasItem::get_use_parent_shader() const{
+bool CanvasItem::get_use_parent_material() const{
 
-	return use_parent_shader;
+	return use_parent_material;
 }
 
-Ref<Shader> CanvasItem::get_shader() const{
+Ref<CanvasItemMaterial> CanvasItem::get_material() const{
 
-	return shader;
+	return material;
 }
 
-void CanvasItem::set_shader_param(const StringName& p_param,const Variant& p_value) {
 
-	VS::get_singleton()->canvas_item_set_shader_param(canvas_item,p_param,p_value);
-}
 
-Variant CanvasItem::get_shader_param(const StringName& p_param) const {
-
-	return VS::get_singleton()->canvas_item_get_shader_param(canvas_item,p_param);
-}
-
-bool CanvasItem::_set(const StringName& p_name, const Variant& p_value) {
-
-	if (shader.is_valid()) {
-		StringName pr = shader->remap_param(p_name);
-		if (pr) {
-			set_shader_param(pr,p_value);
-			return true;
-		}
-	}
-	return false;
-}
-
-bool CanvasItem::_get(const StringName& p_name,Variant &r_ret) const{
-
-	if (shader.is_valid()) {
-		StringName pr = shader->remap_param(p_name);
-		if (pr) {
-			r_ret=get_shader_param(pr);
-			return true;
-		}
-	}
-	return false;
-
-}
-void CanvasItem::_get_property_list( List<PropertyInfo> *p_list) const{
-
-	if (shader.is_valid()) {
-		shader->get_param_list(p_list);
-	}
-}
-
-#ifdef TOOLS_ENABLED
-void CanvasItem::_shader_changed() {
-
-	_change_notify();
-}
-#endif
-
-void CanvasItem::get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const {
-
-	if (p_idx==0 && shader.is_valid() && (p_function.operator String()=="get_shader_param" || p_function.operator String()=="set_shader_param")) {
-
-		List<PropertyInfo> pl;
-		shader->get_param_list(&pl);
-		for(List<PropertyInfo>::Element *E=pl.front();E;E=E->next()) {
-			r_options->push_back("\""+E->get().name.replace_first("shader_param/","")+"\"");
-		}
-
-		return;
-	}
-
-	Node::get_argument_options(p_function,p_idx,r_options);
-}
 
 
 void CanvasItem::_bind_methods() {
@@ -880,9 +990,6 @@ void CanvasItem::_bind_methods() {
 
 	ObjectTypeDB::bind_method(_MD("_set_on_top","on_top"),&CanvasItem::_set_on_top);
 	ObjectTypeDB::bind_method(_MD("_is_on_top"),&CanvasItem::_is_on_top);
-#ifdef TOOLS_ENABLED
-	ObjectTypeDB::bind_method(_MD("_shader_changed"),&CanvasItem::_shader_changed);
-#endif
 	//ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform);
 
 	ObjectTypeDB::bind_method(_MD("draw_line","from","to","color","width"),&CanvasItem::draw_line,DEFVAL(1.0));
@@ -901,20 +1008,18 @@ void CanvasItem::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("draw_set_transform","pos","rot","scale"),&CanvasItem::draw_set_transform);
 	ObjectTypeDB::bind_method(_MD("get_transform"),&CanvasItem::get_transform);
 	ObjectTypeDB::bind_method(_MD("get_global_transform"),&CanvasItem::get_global_transform);
+	ObjectTypeDB::bind_method(_MD("get_global_transform_with_canvas"),&CanvasItem::get_global_transform_with_canvas);
 	ObjectTypeDB::bind_method(_MD("get_viewport_transform"),&CanvasItem::get_viewport_transform);
 	ObjectTypeDB::bind_method(_MD("get_viewport_rect"),&CanvasItem::get_viewport_rect);
 	ObjectTypeDB::bind_method(_MD("get_canvas"),&CanvasItem::get_canvas);
 	ObjectTypeDB::bind_method(_MD("get_world_2d"),&CanvasItem::get_world_2d);
 	//ObjectTypeDB::bind_method(_MD("get_viewport"),&CanvasItem::get_viewport);
 
-	ObjectTypeDB::bind_method(_MD("set_shader","shader"),&CanvasItem::set_shader);
-	ObjectTypeDB::bind_method(_MD("get_shader"),&CanvasItem::get_shader);
-	ObjectTypeDB::bind_method(_MD("set_use_parent_shader","enable"),&CanvasItem::set_use_parent_shader);
-	ObjectTypeDB::bind_method(_MD("get_use_parent_shader"),&CanvasItem::get_use_parent_shader);
-
-	ObjectTypeDB::bind_method(_MD("set_shader_param","param","value"),&CanvasItem::set_shader_param);
-	ObjectTypeDB::bind_method(_MD("get_shader_param","param"),&CanvasItem::get_shader_param);
+	ObjectTypeDB::bind_method(_MD("set_material","material:CanvasItemMaterial"),&CanvasItem::set_material);
+	ObjectTypeDB::bind_method(_MD("get_material:CanvasItemMaterial"),&CanvasItem::get_material);
 
+	ObjectTypeDB::bind_method(_MD("set_use_parent_material","enable"),&CanvasItem::set_use_parent_material);
+	ObjectTypeDB::bind_method(_MD("get_use_parent_material"),&CanvasItem::get_use_parent_material);
 
 	BIND_VMETHOD(MethodInfo("_draw"));
 
@@ -926,8 +1031,8 @@ void CanvasItem::_bind_methods() {
 
 	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"visibility/blend_mode",PROPERTY_HINT_ENUM, "Mix,Add,Sub,Mul,PMAlpha"), _SCS("set_blend_mode"),_SCS("get_blend_mode") );
 	ADD_PROPERTYNZ( PropertyInfo(Variant::INT,"visibility/light_mask",PROPERTY_HINT_ALL_FLAGS), _SCS("set_light_mask"),_SCS("get_light_mask") );
-	ADD_PROPERTYNZ( PropertyInfo(Variant::OBJECT,"shader/shader",PROPERTY_HINT_RESOURCE_TYPE, "CanvasItemShader,CanvasItemShaderGraph"), _SCS("set_shader"),_SCS("get_shader") );
-	ADD_PROPERTYNZ( PropertyInfo(Variant::BOOL,"shader/use_parent"), _SCS("set_use_parent_shader"),_SCS("get_use_parent_shader") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::OBJECT,"material/material",PROPERTY_HINT_RESOURCE_TYPE, "CanvasItemMaterial"), _SCS("set_material"),_SCS("get_material") );
+	ADD_PROPERTYNZ( PropertyInfo(Variant::BOOL,"material/use_parent"), _SCS("set_use_parent_material"),_SCS("get_use_parent_material") );
 	//exporting these two things doesn't really make much sense i think
 	//ADD_PROPERTY( PropertyInfo(Variant::BOOL,"transform/toplevel"), _SCS("set_as_toplevel"),_SCS("is_set_as_toplevel") );
 	//ADD_PROPERTY(PropertyInfo(Variant::BOOL,"transform/notify"),_SCS("set_transform_notify"),_SCS("is_transform_notify_enabled"));
@@ -1004,7 +1109,7 @@ CanvasItem::CanvasItem() : xform_change(this) {
 	block_transform_notify=false;
 //	viewport=NULL;
 	canvas_layer=NULL;
-	use_parent_shader=false;
+	use_parent_material=false;
 	global_invalid=true;
 	light_mask=1;
 
diff --git a/scene/2d/canvas_item.h b/scene/2d/canvas_item.h
index 2441d205ce..0c7be261ab 100644
--- a/scene/2d/canvas_item.h
+++ b/scene/2d/canvas_item.h
@@ -40,6 +40,41 @@ class Font;
 
 class StyleBox;
 
+class CanvasItemMaterial : public Resource{
+
+	OBJ_TYPE(CanvasItemMaterial,Resource);
+	RID material;
+	Ref<Shader> shader;
+	bool unshaded;
+
+protected:
+
+	bool _set(const StringName& p_name, const Variant& p_value);
+	bool _get(const StringName& p_name,Variant &r_ret) const;
+	void _get_property_list( List<PropertyInfo> *p_list) const;
+
+	void _shader_changed();
+	static void _bind_methods();
+
+	void get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const;
+
+public:
+
+	void set_shader(const Ref<Shader>& p_shader);
+	Ref<Shader> get_shader() const;
+
+	void set_shader_param(const StringName& p_param,const Variant& p_value);
+	Variant get_shader_param(const StringName& p_param) const;
+
+	void set_unshaded(bool p_unshaded);
+	bool is_unshaded() const;
+
+	virtual RID get_rid() const;
+	CanvasItemMaterial();
+	~CanvasItemMaterial();
+};
+
+
 class CanvasItem : public Node {
 
 	OBJ_TYPE( CanvasItem, Node );
@@ -81,9 +116,9 @@ private:
 	bool drawing;
 	bool block_transform_notify;
 	bool behind;
-	bool use_parent_shader;
+	bool use_parent_material;
 
-	Ref<Shader> shader;
+	Ref<CanvasItemMaterial> material;
 
 	mutable Matrix32 global_transform;
 	mutable bool global_invalid;
@@ -104,9 +139,6 @@ private:
 	void _queue_sort_children();
 	void _sort_children();
 
-#ifdef TOOLS_ENABLED
-	void _shader_changed();
-#endif
 	void _notify_transform(CanvasItem *p_node);
 
 	void _set_on_top(bool p_on_top) { set_draw_behind_parent(!p_on_top); }
@@ -114,11 +146,6 @@ private:
 
 protected:
 
-	bool _set(const StringName& p_name, const Variant& p_value);
-	bool _get(const StringName& p_name,Variant &r_ret) const;
-	void _get_property_list( List<PropertyInfo> *p_list) const;
-
-
 	_FORCE_INLINE_ void _notify_transform() { if (!is_inside_tree()) return; _notify_transform(this); if (!block_transform_notify) notification(NOTIFICATION_LOCAL_TRANSFORM_CHANGED); }
 
 	void item_rect_changed();
@@ -216,16 +243,12 @@ public:
 	RID get_canvas() const;
 	Ref<World2D> get_world_2d() const;
 
-	void set_shader(const Ref<Shader>& p_shader);
-	Ref<Shader> get_shader() const;
+	void set_material(const Ref<CanvasItemMaterial>& p_material);
+	Ref<CanvasItemMaterial> get_material() const;
 
-	void set_use_parent_shader(bool p_use_parent_shader);
-	bool get_use_parent_shader() const;
+	void set_use_parent_material(bool p_use_parent_material);
+	bool get_use_parent_material() const;
 
-	void set_shader_param(const StringName& p_param,const Variant& p_value);
-	Variant get_shader_param(const StringName& p_param) const;
-
-	void get_argument_options(const StringName& p_function,int p_idx,List<String>*r_options) const;
 
 	CanvasItem();
 	~CanvasItem();
diff --git a/scene/2d/light_2d.cpp b/scene/2d/light_2d.cpp
index cea8c06d3f..93be0c397f 100644
--- a/scene/2d/light_2d.cpp
+++ b/scene/2d/light_2d.cpp
@@ -170,6 +170,29 @@ bool Light2D::is_shadow_enabled() const {
 	return shadow;
 }
 
+void Light2D::set_shadow_buffer_size( int p_size ) {
+
+	shadow_buffer_size=p_size;
+	VS::get_singleton()->canvas_light_set_shadow_buffer_size(canvas_light,shadow_buffer_size);
+}
+
+int Light2D::get_shadow_buffer_size() const {
+
+	return shadow_buffer_size;
+}
+
+void Light2D::set_shadow_esm_multiplier( float p_multiplier) {
+
+	shadow_esm_multiplier=p_multiplier;
+	VS::get_singleton()->canvas_light_set_shadow_esm_multiplier(canvas_light,p_multiplier);
+}
+
+float Light2D::get_shadow_esm_multiplier() const{
+
+	return shadow_esm_multiplier;
+}
+
+
 void Light2D::_notification(int p_what) {
 
 	if (p_what==NOTIFICATION_ENTER_TREE) {
@@ -229,18 +252,26 @@ void Light2D::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_shadow_enabled","enabled"),&Light2D::set_shadow_enabled);
 	ObjectTypeDB::bind_method(_MD("is_shadow_enabled"),&Light2D::is_shadow_enabled);
 
+	ObjectTypeDB::bind_method(_MD("set_shadow_buffer_size","size"),&Light2D::set_shadow_buffer_size);
+	ObjectTypeDB::bind_method(_MD("get_shadow_buffer_size"),&Light2D::get_shadow_buffer_size);
+
+	ObjectTypeDB::bind_method(_MD("set_shadow_esm_multiplier","multiplier"),&Light2D::set_shadow_esm_multiplier);
+	ObjectTypeDB::bind_method(_MD("get_shadow_esm_multiplier"),&Light2D::get_shadow_esm_multiplier);
+
 	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"enabled"),_SCS("set_enabled"),_SCS("is_enabled"));
 	ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"texture",PROPERTY_HINT_RESOURCE_TYPE,"Texture"),_SCS("set_texture"),_SCS("get_texture"));
-	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"texture_offset"),_SCS("set_texture_offset"),_SCS("get_texture_offset"));
+	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2,"offset"),_SCS("set_texture_offset"),_SCS("get_texture_offset"));
 	ADD_PROPERTY( PropertyInfo(Variant::COLOR,"color"),_SCS("set_color"),_SCS("get_color"));
-	ADD_PROPERTY( PropertyInfo(Variant::REAL,"height"),_SCS("set_height"),_SCS("get_height"));
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"z_range_min",PROPERTY_HINT_RANGE,itos(VS::CANVAS_ITEM_Z_MIN)+","+itos(VS::CANVAS_ITEM_Z_MAX)+",1"),_SCS("set_z_range_min"),_SCS("get_z_range_min"));
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"z_range_max",PROPERTY_HINT_RANGE,itos(VS::CANVAS_ITEM_Z_MIN)+","+itos(VS::CANVAS_ITEM_Z_MAX)+",1"),_SCS("set_z_range_max"),_SCS("get_z_range_max"));
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"layer_range_min",PROPERTY_HINT_RANGE,"-512,512,1"),_SCS("set_layer_range_min"),_SCS("get_layer_range_min"));
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"layer_range_max",PROPERTY_HINT_RANGE,"-512,512,1"),_SCS("set_layer_range_max"),_SCS("get_layer_range_max"));
-	ADD_PROPERTY( PropertyInfo(Variant::INT,"item_mask",PROPERTY_HINT_ALL_FLAGS),_SCS("set_item_mask"),_SCS("get_item_mask"));
 	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"subtract"),_SCS("set_subtract_mode"),_SCS("get_subtract_mode"));
-	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"shadow_enabled"),_SCS("set_shadow_enabled"),_SCS("is_shadow_enabled"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"range/height"),_SCS("set_height"),_SCS("get_height"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"range/z_min",PROPERTY_HINT_RANGE,itos(VS::CANVAS_ITEM_Z_MIN)+","+itos(VS::CANVAS_ITEM_Z_MAX)+",1"),_SCS("set_z_range_min"),_SCS("get_z_range_min"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"range/z_max",PROPERTY_HINT_RANGE,itos(VS::CANVAS_ITEM_Z_MIN)+","+itos(VS::CANVAS_ITEM_Z_MAX)+",1"),_SCS("set_z_range_max"),_SCS("get_z_range_max"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"range/layer_min",PROPERTY_HINT_RANGE,"-512,512,1"),_SCS("set_layer_range_min"),_SCS("get_layer_range_min"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"range/layer_max",PROPERTY_HINT_RANGE,"-512,512,1"),_SCS("set_layer_range_max"),_SCS("get_layer_range_max"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"range/item_mask",PROPERTY_HINT_ALL_FLAGS),_SCS("set_item_mask"),_SCS("get_item_mask"));
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"shadow/enabled"),_SCS("set_shadow_enabled"),_SCS("is_shadow_enabled"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"shadow/buffer_size",PROPERTY_HINT_RANGE,"32,16384,1"),_SCS("set_shadow_buffer_size"),_SCS("get_shadow_buffer_size"));
+	ADD_PROPERTY( PropertyInfo(Variant::REAL,"shadow/esm_multiplier",PROPERTY_HINT_RANGE,"1,4096,0.1"),_SCS("set_shadow_esm_multiplier"),_SCS("get_shadow_esm_multiplier"));
 
 
 }
@@ -258,6 +289,8 @@ Light2D::Light2D() {
 	layer_max=0;
 	item_mask=1;
 	subtract_mode=false;
+	shadow_buffer_size=2048;
+	shadow_esm_multiplier=80;
 
 }
 
diff --git a/scene/2d/light_2d.h b/scene/2d/light_2d.h
index dbfd233d39..89f351c3cd 100644
--- a/scene/2d/light_2d.h
+++ b/scene/2d/light_2d.h
@@ -17,6 +17,8 @@ private:
 	int layer_min;
 	int layer_max;
 	int item_mask;
+	int shadow_buffer_size;
+	float shadow_esm_multiplier;
 	bool subtract_mode;
 	Ref<Texture> texture;
 	Vector2 texture_offset;
@@ -68,6 +70,12 @@ public:
 	void set_shadow_enabled( bool p_enabled);
 	bool is_shadow_enabled() const;
 
+	void set_shadow_buffer_size( int p_size );
+	int get_shadow_buffer_size() const;
+
+	void set_shadow_esm_multiplier( float p_multiplier);
+	float get_shadow_esm_multiplier() const;
+
 	virtual Rect2 get_item_rect() const;
 
 	Light2D();
diff --git a/scene/2d/light_occluder_2d.cpp b/scene/2d/light_occluder_2d.cpp
new file mode 100644
index 0000000000..186ea2e248
--- /dev/null
+++ b/scene/2d/light_occluder_2d.cpp
@@ -0,0 +1,201 @@
+#include "light_occluder_2d.h"
+
+
+void OccluderPolygon2D::set_polygon(const DVector<Vector2>& p_polygon) {
+
+	polygon=p_polygon;
+	VS::get_singleton()->canvas_occluder_polygon_set_shape(occ_polygon,p_polygon,closed);
+	emit_changed();
+}
+
+DVector<Vector2> OccluderPolygon2D::get_polygon() const{
+
+	return polygon;
+}
+
+void OccluderPolygon2D::set_closed(bool p_closed) {
+
+	if (closed==p_closed)
+		return;
+	closed=p_closed;
+	VS::get_singleton()->canvas_occluder_polygon_set_shape(occ_polygon,polygon,closed);
+	emit_changed();
+}
+
+bool OccluderPolygon2D::is_closed() const{
+
+	return closed;
+}
+
+void OccluderPolygon2D::set_cull_mode(CullMode p_mode){
+
+	cull=p_mode;
+	VS::get_singleton()->canvas_occluder_polygon_set_cull_mode(occ_polygon,VS::CanvasOccluderPolygonCullMode(p_mode));
+}
+
+OccluderPolygon2D::CullMode OccluderPolygon2D::get_cull_mode() const{
+
+	return cull;
+}
+
+
+RID OccluderPolygon2D::get_rid() const {
+
+	return occ_polygon;
+}
+
+void OccluderPolygon2D::_bind_methods() {
+
+
+	ObjectTypeDB::bind_method(_MD("set_closed","closed"),&OccluderPolygon2D::set_closed);
+	ObjectTypeDB::bind_method(_MD("is_closed"),&OccluderPolygon2D::is_closed);
+
+	ObjectTypeDB::bind_method(_MD("set_cull_mode","cull_mode"),&OccluderPolygon2D::set_cull_mode);
+	ObjectTypeDB::bind_method(_MD("get_cull_mode"),&OccluderPolygon2D::get_cull_mode);
+
+	ObjectTypeDB::bind_method(_MD("set_polygon","polygon"),&OccluderPolygon2D::set_polygon);
+	ObjectTypeDB::bind_method(_MD("get_polygon"),&OccluderPolygon2D::get_polygon);
+
+	ADD_PROPERTY( PropertyInfo(Variant::VECTOR2_ARRAY,"polygon"),_SCS("set_polygon"),_SCS("get_polygon"));
+	ADD_PROPERTY( PropertyInfo(Variant::BOOL,"closed"),_SCS("set_closed"),_SCS("is_closed"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"cull_mode",PROPERTY_HINT_ENUM,"Disabled,ClockWise,CounterClockWise"),_SCS("set_cull_mode"),_SCS("get_cull_mode"));
+
+	BIND_CONSTANT(CULL_DISABLED);
+	BIND_CONSTANT(CULL_CLOCKWISE);
+	BIND_CONSTANT(CULL_COUNTER_CLOCKWISE);
+}
+
+
+OccluderPolygon2D::OccluderPolygon2D() {
+
+	occ_polygon=VS::get_singleton()->canvas_occluder_polygon_create();
+	closed=true;
+	cull=CULL_DISABLED;
+}
+
+OccluderPolygon2D::~OccluderPolygon2D() {
+
+	VS::get_singleton()->free(occ_polygon);
+}
+
+#ifdef DEBUG_ENABLED
+void LightOccluder2D::_poly_changed() {
+
+	update();
+}
+#endif
+
+
+void LightOccluder2D::_notification(int p_what) {
+
+	if (p_what==NOTIFICATION_ENTER_CANVAS) {
+
+		VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,get_canvas());
+		VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform());
+
+	}
+	if (p_what==NOTIFICATION_TRANSFORM_CHANGED) {
+
+		VS::get_singleton()->canvas_light_occluder_set_transform(occluder,get_global_transform());
+	}
+
+	if (p_what==NOTIFICATION_DRAW) {
+
+		if (get_tree()->is_editor_hint()) {
+
+			if (occluder_polygon.is_valid()) {
+
+				DVector<Vector2> poly = occluder_polygon->get_polygon();
+
+				if (poly.size()) {
+					if (occluder_polygon->is_closed()) {
+						Vector<Color> color;
+						color.push_back(Color(0,0,0,0.6));
+						draw_polygon(Variant(poly),color);
+					} else {
+
+						int ps=poly.size();
+						DVector<Vector2>::Read r = poly.read();
+						for(int i=0;i<ps-1;i++) {
+
+							draw_line(r[i],r[i+1],Color(0,0,0,0.6),3);
+						}
+					}
+				}
+			}
+		}
+	}
+
+
+	if (p_what==NOTIFICATION_EXIT_CANVAS) {
+
+		VS::get_singleton()->canvas_light_occluder_attach_to_canvas(occluder,RID());
+	}
+
+
+}
+
+void LightOccluder2D::set_occluder_polygon(const Ref<OccluderPolygon2D>& p_polygon) {
+
+#ifdef DEBUG_ENABLED
+	if (occluder_polygon.is_valid())
+		occluder_polygon->disconnect("changed",this,"_poly_changed");
+#endif
+	occluder_polygon=p_polygon;
+
+	if (occluder_polygon.is_valid())
+		VS::get_singleton()->canvas_light_occluder_set_polygon(occluder,occluder_polygon->get_rid());
+	else
+		VS::get_singleton()->canvas_light_occluder_set_polygon(occluder,RID());
+
+#ifdef DEBUG_ENABLED
+	if (occluder_polygon.is_valid())
+		occluder_polygon->connect("changed",this,"_poly_changed");
+	update();
+#endif
+
+}
+
+Ref<OccluderPolygon2D> LightOccluder2D::get_occluder_polygon() const {
+
+	return occluder_polygon;
+}
+
+void LightOccluder2D::set_occluder_light_mask(int p_mask) {
+
+	mask=p_mask;
+	VS::get_singleton()->canvas_light_occluder_set_light_mask(occluder,mask);
+}
+
+int LightOccluder2D::get_occluder_light_mask() const{
+
+	return mask;
+}
+
+void LightOccluder2D::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("set_occluder_polygon","polygon:OccluderPolygon2D"),&LightOccluder2D::set_occluder_polygon);
+	ObjectTypeDB::bind_method(_MD("get_occluder_polygon:OccluderPolygon2D"),&LightOccluder2D::get_occluder_polygon);
+
+	ObjectTypeDB::bind_method(_MD("set_occluder_light_mask","mask"),&LightOccluder2D::set_occluder_light_mask);
+	ObjectTypeDB::bind_method(_MD("get_occluder_light_mask"),&LightOccluder2D::get_occluder_light_mask);
+
+#ifdef DEBUG_ENABLED
+	ObjectTypeDB::bind_method("_poly_changed",&LightOccluder2D::_poly_changed);
+#endif
+
+	ADD_PROPERTY( PropertyInfo(Variant::OBJECT,"occluder",PROPERTY_HINT_RESOURCE_TYPE,"OccluderPolygon2D"),_SCS("set_occluder_polygon"),_SCS("get_occluder_polygon"));
+	ADD_PROPERTY( PropertyInfo(Variant::INT,"light_mask",PROPERTY_HINT_ALL_FLAGS),_SCS("set_occluder_light_mask"),_SCS("get_occluder_light_mask"));
+}
+
+LightOccluder2D::LightOccluder2D() {
+
+	occluder=VS::get_singleton()->canvas_light_occluder_create();
+	mask=1;
+}
+
+LightOccluder2D::~LightOccluder2D() {
+
+	VS::get_singleton()->free(occluder);
+}
+
diff --git a/scene/2d/light_occluder_2d.h b/scene/2d/light_occluder_2d.h
new file mode 100644
index 0000000000..0343e3697e
--- /dev/null
+++ b/scene/2d/light_occluder_2d.h
@@ -0,0 +1,73 @@
+#ifndef LIGHTOCCLUDER2D_H
+#define LIGHTOCCLUDER2D_H
+
+#include "scene/2d/node_2d.h"
+
+class OccluderPolygon2D : public Resource {
+
+	OBJ_TYPE(OccluderPolygon2D,Resource);
+public:
+
+	enum CullMode {
+		CULL_DISABLED,
+		CULL_CLOCKWISE,
+		CULL_COUNTER_CLOCKWISE
+	};
+private:
+
+
+	RID occ_polygon;
+	DVector<Vector2> polygon;
+	bool closed;
+	CullMode cull;
+
+protected:
+
+	static void _bind_methods();
+public:
+
+	void set_polygon(const DVector<Vector2>& p_polygon);
+	DVector<Vector2> get_polygon() const;
+
+	void set_closed(bool p_closed);
+	bool is_closed() const;
+
+	void set_cull_mode(CullMode p_mode);
+	CullMode get_cull_mode() const;
+
+	virtual RID get_rid() const;
+	OccluderPolygon2D();
+	~OccluderPolygon2D();
+
+};
+
+VARIANT_ENUM_CAST(OccluderPolygon2D::CullMode);
+
+class LightOccluder2D : public Node2D {
+	OBJ_TYPE(LightOccluder2D,Node2D);
+
+	RID occluder;
+	bool enabled;
+	int mask;
+	Ref<OccluderPolygon2D> occluder_polygon;
+
+#ifdef DEBUG_ENABLED
+	void _poly_changed();
+#endif
+
+protected:
+	void _notification(int p_what);
+	static void _bind_methods();
+public:
+
+	void set_occluder_polygon(const Ref<OccluderPolygon2D>& p_polygon);
+	Ref<OccluderPolygon2D> get_occluder_polygon() const;
+
+	void set_occluder_light_mask(int p_mask);
+	int get_occluder_light_mask() const;
+
+	LightOccluder2D();
+	~LightOccluder2D();
+};
+
+#endif // LIGHTOCCLUDER2D_H
diff --git a/scene/3d/camera.cpp b/scene/3d/camera.cpp
index 95eafa0df4..1109139180 100644
--- a/scene/3d/camera.cpp
+++ b/scene/3d/camera.cpp
@@ -152,11 +152,11 @@ void Camera::_get_property_list( List<PropertyInfo> *p_list) const {
 	
 		case PROJECTION_PERSPECTIVE: {
 		
-			p_list->push_back( PropertyInfo( Variant::REAL, "fov" , PROPERTY_HINT_RANGE, "1,89,0.1",PROPERTY_USAGE_NOEDITOR) );
+			p_list->push_back( PropertyInfo( Variant::REAL, "fov" , PROPERTY_HINT_RANGE, "1,179,0.1",PROPERTY_USAGE_NOEDITOR) );
 			if (keep_aspect==KEEP_WIDTH)
-				p_list->push_back( PropertyInfo( Variant::REAL, "fovx" , PROPERTY_HINT_RANGE, "1,89,0.1",PROPERTY_USAGE_EDITOR) );
+				p_list->push_back( PropertyInfo( Variant::REAL, "fovx" , PROPERTY_HINT_RANGE, "1,179,0.1",PROPERTY_USAGE_EDITOR) );
 			else
-				p_list->push_back( PropertyInfo( Variant::REAL, "fovy" , PROPERTY_HINT_RANGE, "1,89,0.1",PROPERTY_USAGE_EDITOR) );
+				p_list->push_back( PropertyInfo( Variant::REAL, "fovy" , PROPERTY_HINT_RANGE, "1,179,0.1",PROPERTY_USAGE_EDITOR) );
 
 			
 		} break;
diff --git a/scene/3d/visual_instance.cpp b/scene/3d/visual_instance.cpp
index a82c69e67f..45c7fa912c 100644
--- a/scene/3d/visual_instance.cpp
+++ b/scene/3d/visual_instance.cpp
@@ -310,6 +310,17 @@ int GeometryInstance::get_baked_light_texture_id() const{
 	return baked_light_texture_id;
 }
 
+void GeometryInstance::set_extra_cull_margin(float p_margin) {
+
+	ERR_FAIL_COND(p_margin<0);
+	extra_cull_margin=p_margin;
+	VS::get_singleton()->instance_set_extra_visibility_margin(get_instance(),extra_cull_margin);
+}
+
+float GeometryInstance::get_extra_cull_margin() const{
+
+	return extra_cull_margin;
+}
 
 void GeometryInstance::_bind_methods() {
 
@@ -328,6 +339,9 @@ void GeometryInstance::_bind_methods() {
 	ObjectTypeDB::bind_method(_MD("set_baked_light_texture_id","id"), &GeometryInstance::set_baked_light_texture_id);
 	ObjectTypeDB::bind_method(_MD("get_baked_light_texture_id"), &GeometryInstance::get_baked_light_texture_id);
 
+	ObjectTypeDB::bind_method(_MD("set_extra_cull_margin","margin"), &GeometryInstance::set_extra_cull_margin);
+	ObjectTypeDB::bind_method(_MD("get_extra_cull_margin"), &GeometryInstance::get_extra_cull_margin);
+
 	ObjectTypeDB::bind_method(_MD("_baked_light_changed"), &GeometryInstance::_baked_light_changed);
 
 	ADD_PROPERTYI( PropertyInfo( Variant::BOOL, "geometry/visible"), _SCS("set_flag"), _SCS("get_flag"),FLAG_VISIBLE);
@@ -336,6 +350,7 @@ void GeometryInstance::_bind_methods() {
 	ADD_PROPERTYI( PropertyInfo( Variant::BOOL, "geometry/receive_shadows"), _SCS("set_flag"), _SCS("get_flag"),FLAG_RECEIVE_SHADOWS);
 	ADD_PROPERTY( PropertyInfo( Variant::INT, "geometry/range_begin",PROPERTY_HINT_RANGE,"0,32768,0.01"), _SCS("set_draw_range_begin"), _SCS("get_draw_range_begin"));
 	ADD_PROPERTY( PropertyInfo( Variant::INT, "geometry/range_end",PROPERTY_HINT_RANGE,"0,32768,0.01"), _SCS("set_draw_range_end"), _SCS("get_draw_range_end"));
+	ADD_PROPERTY( PropertyInfo( Variant::REAL, "geometry/extra_cull_margin",PROPERTY_HINT_RANGE,"0,16384,0"), _SCS("set_extra_cull_margin"), _SCS("get_extra_cull_margin"));
 	ADD_PROPERTYI( PropertyInfo( Variant::BOOL, "geometry/billboard"), _SCS("set_flag"), _SCS("get_flag"),FLAG_BILLBOARD);
 	ADD_PROPERTYI( PropertyInfo( Variant::BOOL, "geometry/billboard_y"), _SCS("set_flag"), _SCS("get_flag"),FLAG_BILLBOARD_FIX_Y);
 	ADD_PROPERTYI( PropertyInfo( Variant::BOOL, "geometry/depth_scale"), _SCS("set_flag"), _SCS("get_flag"),FLAG_DEPH_SCALE);
diff --git a/scene/3d/visual_instance.h b/scene/3d/visual_instance.h
index e9fefe1ba0..e08acbe9a2 100644
--- a/scene/3d/visual_instance.h
+++ b/scene/3d/visual_instance.h
@@ -108,6 +108,7 @@ private:
 	void _find_baked_light();
 	BakedLightInstance *baked_light_instance;
 	int baked_light_texture_id;
+	float extra_cull_margin;
 
 	void _baked_light_changed();
 	void _update_visibility();
@@ -132,6 +133,9 @@ public:
 	void set_baked_light_texture_id(int p_id);
 	int get_baked_light_texture_id() const;
 
+	void set_extra_cull_margin(float p_margin);
+	float get_extra_cull_margin() const;
+
 	GeometryInstance();
 };
 
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index ff525203bf..f90db42614 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -80,6 +80,7 @@
 #include "scene/2d/particles_2d.h"
 #include "scene/2d/path_2d.h"
 #include "scene/2d/light_2d.h"
+#include "scene/2d/light_occluder_2d.h"
 
 #include "scene/2d/canvas_item.h"
 #include "scene/2d/sprite.h"
@@ -454,6 +455,7 @@ void register_scene_types() {
 	//ObjectTypeDB::set_type_enabled("BodyVolumeCylinder",false);
 	//ObjectTypeDB::set_type_enabled("BodyVolumeConvexPolygon",false);
 
+	ObjectTypeDB::register_type<CanvasItemMaterial>();
 	ObjectTypeDB::register_virtual_type<CanvasItem>();
 	ObjectTypeDB::register_type<Node2D>();
 	ObjectTypeDB::register_type<Particles2D>();
@@ -476,6 +478,8 @@ void register_scene_types() {
 	ObjectTypeDB::register_type<VisibilityEnabler2D>();
 	ObjectTypeDB::register_type<Polygon2D>();
 	ObjectTypeDB::register_type<Light2D>();
+	ObjectTypeDB::register_type<LightOccluder2D>();
+	ObjectTypeDB::register_type<OccluderPolygon2D>();
 	ObjectTypeDB::register_type<YSort>();
 
 	ObjectTypeDB::set_type_enabled("CollisionShape2D",false);
diff --git a/scene/scene_string_names.cpp b/scene/scene_string_names.cpp
index af5e6d4165..c30ff0044e 100644
--- a/scene/scene_string_names.cpp
+++ b/scene/scene_string_names.cpp
@@ -41,6 +41,7 @@ SceneStringNames::SceneStringNames() {
 	visibility_changed=StaticCString::create("visibility_changed");
 	input_event=StaticCString::create("input_event");
 	shader_shader=StaticCString::create("shader/shader");
+	shader_unshaded=StaticCString::create("shader/unshaded");
 	enter_tree=StaticCString::create("enter_tree");
 	exit_tree=StaticCString::create("exit_tree");
 	item_rect_changed=StaticCString::create("item_rect_changed");
diff --git a/scene/scene_string_names.h b/scene/scene_string_names.h
index 14e5e83b8d..184cbe347b 100644
--- a/scene/scene_string_names.h
+++ b/scene/scene_string_names.h
@@ -56,6 +56,7 @@ public:
 	StringName _input_event;
 	StringName item_rect_changed;
 	StringName shader_shader;
+	StringName shader_unshaded;
 	StringName enter_tree;
 	StringName exit_tree;
 	StringName size_flags_changed;
diff --git a/servers/visual/rasterizer.h b/servers/visual/rasterizer.h
index 4c9d0491b1..62ab8b3c56 100644
--- a/servers/visual/rasterizer.h
+++ b/servers/visual/rasterizer.h
@@ -572,8 +572,8 @@ public:
 	struct CanvasLight {
 
 
+
 		bool enabled;
-		bool shadow;
 		Color color;
 		Matrix32 xform;
 		float height;
@@ -586,21 +586,26 @@ public:
 		RID texture;
 		Vector2 texture_offset;
 		RID canvas;
+		RID shadow_buffer;
+		int shadow_buffer_size;
+		float shadow_esm_mult;
 
 
 		void *texture_cache; // implementation dependent
 		Rect2 rect_cache;
 		Matrix32 xform_cache;
+		float radius_cache; //used for shadow far plane
+		CameraMatrix shadow_matrix_cache;
 
 		Matrix32 light_shader_xform;
 		Vector2 light_shader_pos;
 
+		CanvasLight *shadows_next_ptr;
 		CanvasLight *filter_next_ptr;
 		CanvasLight *next_ptr;
 
 		CanvasLight() {
-			enabled=true;
-			shadow=false;
+			enabled=true;			
 			color=Color(1,1,1);
 			height=0;
 			z_min=-1024;
@@ -612,9 +617,24 @@ public:
 			texture_cache=NULL;
 			next_ptr=NULL;
 			filter_next_ptr=NULL;
+			shadow_buffer_size=2048;
+			shadow_esm_mult=80;
+
 		}
 	};
 
+	struct CanvasItem;
+
+	struct CanvasItemMaterial  {
+
+		RID shader;
+		Map<StringName,Variant> shader_param;
+		uint32_t shader_version;
+		Set<CanvasItem*> owners;
+		bool unshaded;
+
+		CanvasItemMaterial() {unshaded=false; shader_version=0; }
+	};
 
 	struct CanvasItem {
 
@@ -744,16 +764,14 @@ public:
 		mutable bool rect_dirty;
 		mutable Rect2 rect;
 		CanvasItem*next;
-		RID shader;
-		Map<StringName,Variant> shader_param;
-		uint32_t shader_version;
+		CanvasItemMaterial* material;
 
 
 		float final_opacity;
 		Matrix32 final_transform;
 		Rect2 final_clip_rect;
 		CanvasItem* final_clip_owner;
-		CanvasItem* shader_owner;
+		CanvasItem* material_owner;
 		ViewportRender *vp_render;
 
 		Rect2 global_rect_cache;
@@ -881,8 +899,8 @@ public:
 			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() { light_mask=1; vp_render=NULL; next=NULL; final_clip_owner=NULL; clip=false; final_opacity=1;  blend_mode=VS::MATERIAL_BLEND_MODE_MIX; visible=true; rect_dirty=true; custom_rect=false; ontop=true; shader_version=0; shader_owner=NULL;}
+		void clear() { for (int i=0;i<commands.size();i++) memdelete( commands[i] ); commands.clear(); clip=false; rect_dirty=true; final_clip_owner=NULL;  material_owner=NULL;}
+		CanvasItem() { light_mask=1; vp_render=NULL; next=NULL; final_clip_owner=NULL; clip=false; final_opacity=1;  blend_mode=VS::MATERIAL_BLEND_MODE_MIX; visible=true; rect_dirty=true; custom_rect=false; ontop=true; material_owner=NULL; material=NULL; }
 		virtual ~CanvasItem() { clear(); }
 	};
 
@@ -905,7 +923,36 @@ public:
 	virtual void canvas_set_transform(const Matrix32& p_transform)=0;
 
 	virtual void canvas_render_items(CanvasItem *p_item_list,int p_z,const Color& p_modulate,CanvasLight *p_light)=0;
+	virtual void canvas_debug_viewport_shadows(CanvasLight* p_lights_with_shadow)=0;
+	/* LIGHT SHADOW MAPPING */
 
+	virtual RID canvas_light_occluder_create()=0;
+	virtual void canvas_light_occluder_set_polylines(RID p_occluder, const DVector<Vector2>& p_lines)=0;
+
+
+	virtual RID canvas_light_shadow_buffer_create(int p_width)=0;
+
+	struct CanvasLightOccluderInstance {
+
+
+		bool enabled;
+		RID canvas;
+		RID polygon;
+		RID polygon_buffer;
+		Rect2 aabb_cache;
+		Matrix32 xform;
+		Matrix32 xform_cache;
+		int light_mask;
+		VS::CanvasOccluderPolygonCullMode cull_cache;
+
+		CanvasLightOccluderInstance *next;
+
+		CanvasLightOccluderInstance() { enabled=true; next=NULL; light_mask=1; cull_cache=VS::CANVAS_OCCLUDER_POLYGON_CULL_DISABLED; }
+	};
+
+
+
+	virtual void canvas_light_shadow_buffer_update(RID p_buffer, const Matrix32& p_light_xform, int p_light_mask,float p_near, float p_far, CanvasLightOccluderInstance* p_occluders, CameraMatrix *p_xform_cache)=0;
 
 	/* ENVIRONMENT */
 	
@@ -945,6 +992,8 @@ public:
 	virtual bool is_environment(const RID& p_rid) const=0;
 	virtual bool is_shader(const RID& p_rid) const=0;
 
+	virtual bool is_canvas_light_occluder(const RID& p_rid) const=0;
+
 	virtual void free(const RID& p_rid)=0;
 
 	virtual void init()=0;
diff --git a/servers/visual/visual_server_raster.cpp b/servers/visual/visual_server_raster.cpp
index feb14d8a9d..3bcf0b8a3e 100644
--- a/servers/visual/visual_server_raster.cpp
+++ b/servers/visual/visual_server_raster.cpp
@@ -3765,55 +3765,32 @@ void VisualServerRaster::canvas_item_set_z_as_relative_to_parent(RID p_item, boo
 
 }
 
-void VisualServerRaster::canvas_item_set_use_parent_shader(RID p_item, bool p_enable) {
+void VisualServerRaster::canvas_item_set_use_parent_material(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
 	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
 	ERR_FAIL_COND(!canvas_item);
-	canvas_item->use_parent_shader=p_enable;
+	canvas_item->use_parent_material=p_enable;
 
 }
 
-void VisualServerRaster::canvas_item_set_shader(RID p_item, RID p_shader) {
+void VisualServerRaster::canvas_item_set_material(RID p_item, RID p_material) {
 
 	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{
+	if (canvas_item->material)
+		canvas_item->material->owners.erase(canvas_item);
 
-	CanvasItem *canvas_item = canvas_item_owner.get( p_item );
-	ERR_FAIL_COND_V(!canvas_item,RID());
-	return canvas_item->shader;
+	canvas_item->material=NULL;
 
-}
-
-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);
+	if (canvas_item_material_owner.owns(p_material)) {
+		canvas_item->material=canvas_item_material_owner.get(p_material);
+		canvas_item->material->owners.insert(canvas_item);
 	}
-
-	return canvas_item->shader_param[p_param];
 }
 
-
 void VisualServerRaster::canvas_item_set_sort_children_by_y(RID p_item, bool p_enable) {
 
 	VS_CHANGED;
@@ -3989,19 +3966,41 @@ void VisualServerRaster::canvas_light_set_shadow_enabled(RID p_light, bool p_ena
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
-	clight->shadow=p_enabled;
+
+	if (clight->shadow_buffer.is_valid()==p_enabled)
+		return;
+	if (p_enabled) {
+		clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
+	} else {
+		rasterizer->free(clight->shadow_buffer);
+		clight->shadow_buffer=RID();
+
+	}
 
 }
+
 void VisualServerRaster::canvas_light_set_shadow_buffer_size(RID p_light, int p_size){
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
 
+	ERR_FAIL_COND(p_size<32 || p_size>16384);
+
+	clight->shadow_buffer_size=nearest_power_of_2(p_size);
+
+
+	if (clight->shadow_buffer.is_valid()) {
+		rasterizer->free(clight->shadow_buffer);
+		clight->shadow_buffer=rasterizer->canvas_light_shadow_buffer_create(clight->shadow_buffer_size);
+	}
+
 }
-void VisualServerRaster::canvas_light_set_shadow_filter(RID p_light, int p_size){
+
+void VisualServerRaster::canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier) {
 
 	Rasterizer::CanvasLight *clight = canvas_light_owner.get(p_light);
 	ERR_FAIL_COND(!clight);
+	clight->shadow_esm_mult=p_multiplier;
 
 }
 
@@ -4009,26 +4008,217 @@ void VisualServerRaster::canvas_light_set_shadow_filter(RID p_light, int p_size)
 
 RID VisualServerRaster::canvas_light_occluder_create() {
 
-	return RID();
+	Rasterizer::CanvasLightOccluderInstance *occluder = memnew( Rasterizer::CanvasLightOccluderInstance );
+
+	return canvas_light_occluder_owner.make_rid( occluder );
+
 }
 
 void VisualServerRaster::canvas_light_occluder_attach_to_canvas(RID p_occluder,RID p_canvas) {
 
+	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!occluder);
 
+	if (occluder->canvas.is_valid()) {
+
+		Canvas *canvas = canvas_owner.get(occluder->canvas);
+		canvas->occluders.erase(occluder);
+	}
+
+	if (!canvas_owner.owns(p_canvas))
+		p_canvas=RID();
+
+	occluder->canvas=p_canvas;
+
+	if (occluder->canvas.is_valid()) {
+
+		Canvas *canvas = canvas_owner.get(occluder->canvas);
+		canvas->occluders.insert(occluder);
+	}
 }
 
 void VisualServerRaster::canvas_light_occluder_set_enabled(RID p_occluder,bool p_enabled){
 
+	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!occluder);
+
+	occluder->enabled=p_enabled;
 
 }
 
-void VisualServerRaster::canvas_light_occluder_set_shape(RID p_occluder,const DVector<Vector2>& p_shape){
+void VisualServerRaster::canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon) {
 
+	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!occluder);
+
+	if (occluder->polygon.is_valid()) {
+		CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
+		if (occluder_poly) {
+			occluder_poly->owners.erase(occluder);
+		}
+	}
+
+	occluder->polygon=p_polygon;
+	occluder->polygon_buffer=RID();
+
+	if (occluder->polygon.is_valid()) {
+		CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_polygon);
+		if (!occluder_poly)
+			occluder->polygon=RID();
+		ERR_FAIL_COND(!occluder_poly);
+		occluder_poly->owners.insert(occluder);
+		occluder->polygon_buffer=occluder_poly->occluder;
+		occluder->aabb_cache=occluder_poly->aabb;
+		occluder->cull_cache=occluder_poly->cull_mode;
+	}
 
 }
 
 
 
+
+void VisualServerRaster::canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform) {
+
+	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!occluder);
+
+	occluder->xform=p_xform;
+
+}
+
+void VisualServerRaster::canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask) {
+
+	Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_occluder);
+	ERR_FAIL_COND(!occluder);
+
+	occluder->light_mask=p_mask;
+
+}
+
+
+RID VisualServerRaster::canvas_occluder_polygon_create() {
+
+	CanvasLightOccluderPolygon * occluder_poly = memnew( CanvasLightOccluderPolygon );
+	occluder_poly->occluder=rasterizer->canvas_light_occluder_create();
+	return canvas_light_occluder_polygon_owner.make_rid(occluder_poly);
+
+}
+
+void VisualServerRaster::canvas_occluder_polygon_set_shape(RID p_occluder_polygon, const DVector<Vector2>& p_shape, bool p_close){
+
+	if (p_shape.size()<3) {
+		canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,p_shape);
+		return;
+	}
+
+	DVector<Vector2> lines;
+	int lc = p_shape.size()*2;
+
+	lines.resize(lc-(p_close?0:2));
+	{
+		DVector<Vector2>::Write w = lines.write();
+		DVector<Vector2>::Read r = p_shape.read();
+
+		int max=lc/2;
+		if (!p_close) {
+			max--;
+		}
+		for(int i=0;i<max;i++) {
+
+			Vector2 a = r[i];
+			Vector2 b = r[(i+1)%(lc/2)];
+			w[i*2+0]=a;
+			w[i*2+1]=b;
+		}
+
+	}
+
+	canvas_occluder_polygon_set_shape_as_lines(p_occluder_polygon,lines);
+}
+
+void VisualServerRaster::canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape) {
+
+	CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
+	ERR_FAIL_COND(!occluder_poly);
+	ERR_FAIL_COND(p_shape.size()&1);
+
+	int lc = p_shape.size();
+	occluder_poly->aabb=Rect2();
+	{
+		DVector<Vector2>::Read r = p_shape.read();
+		for(int i=0;i<lc;i++) {
+			if (i==0)
+				occluder_poly->aabb.pos=r[i];
+			else
+				occluder_poly->aabb.expand_to(r[i]);
+		}
+	}
+
+	rasterizer->canvas_light_occluder_set_polylines(occluder_poly->occluder,p_shape);
+	for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
+		E->get()->aabb_cache=occluder_poly->aabb;
+	}
+}
+
+void VisualServerRaster::canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode) {
+
+	CanvasLightOccluderPolygon * occluder_poly = canvas_light_occluder_polygon_owner.get(p_occluder_polygon);
+	ERR_FAIL_COND(!occluder_poly);
+	occluder_poly->cull_mode=p_mode;
+	for( Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=occluder_poly->owners.front();E;E=E->next()) {
+		E->get()->cull_cache=p_mode;
+	}
+
+}
+
+RID VisualServerRaster::canvas_item_material_create() {
+
+	Rasterizer::CanvasItemMaterial *material = memnew( Rasterizer::CanvasItemMaterial );
+	return canvas_item_material_owner.make_rid(material);
+
+}
+
+void VisualServerRaster::canvas_item_material_set_shader(RID p_material, RID p_shader){
+
+	VS_CHANGED;
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	ERR_FAIL_COND(!material);
+	material->shader=p_shader;
+
+}
+void VisualServerRaster::canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value){
+
+	VS_CHANGED;
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	ERR_FAIL_COND(!material);
+	if (p_value.get_type()==Variant::NIL)
+		material->shader_param.erase(p_param);
+	else
+		material->shader_param[p_param]=p_value;
+
+
+}
+Variant VisualServerRaster::canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const{
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	ERR_FAIL_COND_V(!material,Variant());
+	if (!material->shader_param.has(p_param)) {
+		ERR_FAIL_COND_V(!material->shader.is_valid(),Variant());
+		return rasterizer->shader_get_default_param(material->shader,p_param);
+	}
+
+	return material->shader_param[p_param];
+}
+
+void VisualServerRaster::canvas_item_material_set_unshaded(RID p_material, bool p_unshaded){
+
+	VS_CHANGED;
+	Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get( p_material );
+	ERR_FAIL_COND(!material);
+	material->unshaded=p_unshaded;
+
+}
+
+
 /******** CANVAS *********/
 
 
@@ -4285,6 +4475,10 @@ void VisualServerRaster::free( RID p_rid ) {
 			E->get()->canvas=RID();
 		}
 
+		for (Set<Rasterizer::CanvasLightOccluderInstance*>::Element *E=canvas->occluders.front();E;E=E->next()) {
+
+			E->get()->canvas=RID();
+		}
 
 		canvas_owner.free( p_rid );
 		
@@ -4314,10 +4508,26 @@ void VisualServerRaster::free( RID p_rid ) {
 			canvas_item->child_items[i]->parent=RID();
 		}
 
+		if (canvas_item->material) {
+			canvas_item->material->owners.erase(canvas_item);
+		}
+
 		canvas_item_owner.free( p_rid );
 		
 		memdelete( canvas_item );
 
+	} else if (canvas_item_material_owner.owns(p_rid)) {
+
+		Rasterizer::CanvasItemMaterial *material = canvas_item_material_owner.get(p_rid);
+		ERR_FAIL_COND(!material);
+		for(Set<Rasterizer::CanvasItem*>::Element *E=material->owners.front();E;E=E->next()) {
+
+			E->get()->material=NULL;
+		}
+
+		canvas_item_material_owner.free(p_rid);
+		memdelete(material);
+
 	} else if (canvas_light_owner.owns(p_rid)) {
 
 		Rasterizer::CanvasLight *canvas_light = canvas_light_owner.get(p_rid);
@@ -4329,9 +4539,44 @@ void VisualServerRaster::free( RID p_rid ) {
 				canvas->lights.erase(canvas_light);
 		}
 
+		if (canvas_light->shadow_buffer.is_valid())
+			rasterizer->free(canvas_light->shadow_buffer);
+
 		canvas_light_owner.free( p_rid );
 		memdelete( canvas_light );
 
+	} else if (canvas_light_occluder_owner.owns(p_rid)) {
+
+		Rasterizer::CanvasLightOccluderInstance *occluder = canvas_light_occluder_owner.get(p_rid);
+		ERR_FAIL_COND(!occluder);
+
+		if (occluder->polygon.is_valid()) {
+
+			CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(occluder->polygon);
+			if (occluder_poly) {
+				occluder_poly->owners.erase(occluder);
+			}
+
+		}
+
+		canvas_light_occluder_owner.free( p_rid );
+		memdelete(occluder);
+
+	} else if (canvas_light_occluder_polygon_owner.owns(p_rid)) {
+
+		CanvasLightOccluderPolygon *occluder_poly = canvas_light_occluder_polygon_owner.get(p_rid);
+		ERR_FAIL_COND(!occluder_poly);
+		rasterizer->free(occluder_poly->occluder);
+
+		while(occluder_poly->owners.size()) {
+
+			occluder_poly->owners.front()->get()->polygon=RID();
+			occluder_poly->owners.erase( occluder_poly->owners.front() );
+		}
+
+		canvas_light_occluder_polygon_owner.free( p_rid );
+		memdelete(occluder_poly);
+
 	} else if (scenario_owner.owns(p_rid)) {
 		
 		Scenario *scenario=scenario_owner.get(p_rid);
@@ -6410,7 +6655,7 @@ void VisualServerRaster::_render_canvas_item_viewport(VisualServer* p_self,void
 
 }
 
-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) {
+void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity,int p_z,Rasterizer::CanvasItem **z_list,Rasterizer::CanvasItem **z_last_list,CanvasItem *p_canvas_clip,CanvasItem *p_material_owner) {
 
 	CanvasItem *ci = p_canvas_item;
 
@@ -6455,11 +6700,11 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 		ci->vp_render=NULL;
 	}
 
-	if (ci->use_parent_shader && p_shader_owner)
-		ci->shader_owner=p_shader_owner;
+	if (ci->use_parent_material && p_material_owner)
+		ci->material_owner=p_material_owner;
 	else {
-		p_shader_owner=ci;
-		ci->shader_owner=NULL;
+		p_material_owner=ci;
+		ci->material_owner=NULL;
 	}
 
 
@@ -6493,7 +6738,7 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 
 		if (child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_shader_owner);
+		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_material_owner);
 	}
 
 
@@ -6524,7 +6769,7 @@ void VisualServerRaster::_render_canvas_item(CanvasItem *p_canvas_item,const Mat
 
 		if (!child_items[i]->ontop)
 			continue;
-		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_shader_owner);
+		_render_canvas_item(child_items[i],xform,p_clip_rect,opacity,p_z,z_list,z_last_list,(CanvasItem*)ci->final_clip_owner,p_material_owner);
 	}
 
 }
@@ -6658,6 +6903,8 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 
 		Rect2 clip_rect(0,0,viewport_rect.width,viewport_rect.height);
 		Rasterizer::CanvasLight *lights=NULL;
+		Rasterizer::CanvasLight *lights_with_shadow=NULL;
+		Rect2 shadow_rect;
 
 		for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
 
@@ -6676,6 +6923,7 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 					cl->rect_cache=Rect2(-offset+cl->texture_offset,tsize);
 					cl->xform_cache=xf * cl->xform;
 
+
 					if (clip_rect.intersects_transformed(cl->xform_cache,cl->rect_cache)) {
 						cl->filter_next_ptr=lights;
 						lights=cl;
@@ -6685,11 +6933,18 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 						scale.elements[2]=cl->rect_cache.pos;
 						cl->light_shader_xform = (cl->xform_cache * scale).affine_inverse();
 						cl->light_shader_pos=cl->xform_cache[2];
+						if (cl->shadow_buffer.is_valid()) {
+							cl->shadows_next_ptr=lights_with_shadow;
+							if (lights_with_shadow==NULL) {
+								shadow_rect = cl->xform_cache.xform(cl->rect_cache);
+							} else {
+								shadow_rect=shadow_rect.merge( cl->xform_cache.xform(cl->rect_cache) );
+							}
+							lights_with_shadow=cl;
+							cl->radius_cache=cl->rect_cache.size.length();
+
+						}
 					}
-
-
-
-
 				}
 			}
 
@@ -6697,6 +6952,38 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 
 		}
 
+		if (lights_with_shadow) {
+			//update shadows if any
+
+			Rasterizer::CanvasLightOccluderInstance * occluders=NULL;
+
+			//make list of occluders
+			for (Map<RID,Viewport::CanvasData>::Element *E=p_viewport->canvas_map.front();E;E=E->next()) {
+
+				Matrix32 xf = p_viewport->global_transform * E->get().transform;
+
+				for(Set<Rasterizer::CanvasLightOccluderInstance*>::Element *F=E->get().canvas->occluders.front();F;F=F->next()) {
+
+					F->get()->xform_cache = xf * F->get()->xform;
+					if (shadow_rect.intersects_transformed(F->get()->xform_cache,F->get()->aabb_cache)) {
+
+						F->get()->next=occluders;
+						occluders=F->get();
+
+					}
+				}
+			}
+			//update the light shadowmaps with them
+			Rasterizer::CanvasLight *light=lights_with_shadow;
+			while(light) {
+
+				rasterizer->canvas_light_shadow_buffer_update(light->shadow_buffer,light->xform_cache.affine_inverse(),light->item_mask,light->radius_cache/1000.0,light->radius_cache*1.1,occluders,&light->shadow_matrix_cache);
+				light=light->shadows_next_ptr;
+			}
+
+			rasterizer->set_viewport(viewport_rect); //must reset viewport afterwards
+		}
+
 		for (Map<Viewport::CanvasKey,Viewport::CanvasData*>::Element *E=canvas_map.front();E;E=E->next()) {
 
 
@@ -6719,6 +7006,8 @@ void VisualServerRaster::_draw_viewport(Viewport *p_viewport,int p_ofs_x, int p_
 			i++;
 
 		}
+
+		rasterizer->canvas_debug_viewport_shadows(lights_with_shadow);
 	}
 
 	//capture
diff --git a/servers/visual/visual_server_raster.h b/servers/visual/visual_server_raster.h
index 9b2b0c9c1a..b9a3f83364 100644
--- a/servers/visual/visual_server_raster.h
+++ b/servers/visual/visual_server_raster.h
@@ -371,7 +371,7 @@ class VisualServerRaster : public VisualServer {
 
 
 
-
+	mutable RID_Owner<Rasterizer::CanvasItemMaterial> canvas_item_material_owner;
 
 	struct CanvasItem : public Rasterizer::CanvasItem {
 
@@ -384,7 +384,7 @@ class VisualServerRaster : public VisualServer {
 		bool sort_y;
 		float opacity;
 		float self_opacity;
-		bool use_parent_shader;
+		bool use_parent_material;
 
 
 		Vector<CanvasItem*> child_items;
@@ -396,7 +396,7 @@ class VisualServerRaster : public VisualServer {
 			opacity=1;
 			self_opacity=1;
 			sort_y=false;
-			use_parent_shader=false;
+			use_parent_material=false;
 			z_relative=true;
 		}
 	};
@@ -410,6 +410,24 @@ class VisualServerRaster : public VisualServer {
 		}
 	};
 
+	struct CanvasLightOccluder;
+
+	struct CanvasLightOccluderPolygon {
+
+		bool active;
+		Rect2 aabb;
+		CanvasOccluderPolygonCullMode cull_mode;
+		RID occluder;
+		Set<Rasterizer::CanvasLightOccluderInstance*> owners;
+
+		CanvasLightOccluderPolygon() { active=false; cull_mode=CANVAS_OCCLUDER_POLYGON_CULL_DISABLED; }
+	};
+
+
+	RID_Owner<CanvasLightOccluderPolygon> canvas_light_occluder_polygon_owner;
+
+	RID_Owner<Rasterizer::CanvasLightOccluderInstance> canvas_light_occluder_owner;
+
 	struct CanvasLight;
 
 	struct Canvas {
@@ -422,6 +440,7 @@ class VisualServerRaster : public VisualServer {
 		};
 
 		Set<Rasterizer::CanvasLight*> lights;
+		Set<Rasterizer::CanvasLightOccluderInstance*> occluders;
 
 		Vector<ChildItem> child_items;
 		Color modulate;
@@ -610,7 +629,7 @@ class VisualServerRaster : public VisualServer {
 	void _render_camera(Viewport *p_viewport,Camera *p_camera, Scenario *p_scenario);
 	static void _render_canvas_item_viewport(VisualServer* p_self,void *p_vp,const Rect2& p_rect);
 	void _render_canvas_item_tree(CanvasItem *p_canvas_item, const Matrix32& p_transform, const Rect2& p_clip_rect, const Color &p_modulate, Rasterizer::CanvasLight *p_lights);
-	void _render_canvas_item(CanvasItem *p_canvas_item,const Matrix32& p_transform,const Rect2& p_clip_rect, float p_opacity,int p_z,Rasterizer::CanvasItem **z_list,Rasterizer::CanvasItem **z_last_list,CanvasItem *p_canvas_clip,CanvasItem *p_shader_owner);
+	void _render_canvas_item(CanvasItem *p_canvas_item, const Matrix32& p_transform, const Rect2& p_clip_rect, float p_opacity, int p_z, Rasterizer::CanvasItem **z_list, Rasterizer::CanvasItem **z_last_list, CanvasItem *p_canvas_clip, CanvasItem *p_material_owner);
 	void _render_canvas(Canvas *p_canvas, const Matrix32 &p_transform, Rasterizer::CanvasLight *p_lights);
 	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);
@@ -1131,15 +1150,8 @@ public:
 	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 void canvas_item_set_material(RID p_item, RID p_material);
+	virtual void canvas_item_set_use_parent_material(RID p_item, bool p_enable);
 
 	virtual RID canvas_light_create();
 	virtual void canvas_light_attach_to_canvas(RID p_light,RID p_canvas);
@@ -1156,17 +1168,36 @@ public:
 	virtual void canvas_light_set_subtract_mode(RID p_light, bool p_enable);
 	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 void canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier);
 
 
 	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_light_occluder_set_polygon(RID p_occluder,RID p_polygon);
+	virtual void canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform);
+	virtual void canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask);
+
+
+	virtual RID canvas_occluder_polygon_create();
+	virtual void canvas_occluder_polygon_set_shape(RID p_occluder_polygon,const DVector<Vector2>& p_shape,bool p_close);
+	virtual void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape);
+	virtual void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode);
+
+
 
 	virtual void canvas_item_clear(RID p_item);
 	virtual void canvas_item_raise(RID p_item);
 
+	/* CANVAS ITEM MATERIAL */
+
+	virtual RID canvas_item_material_create();
+	virtual void canvas_item_material_set_shader(RID p_material, RID p_shader);
+	virtual void canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value);
+	virtual Variant canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const;
+	virtual void canvas_item_material_set_unshaded(RID p_material, bool p_unshaded);
+
+
 	/* 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);
diff --git a/servers/visual/visual_server_wrap_mt.h b/servers/visual/visual_server_wrap_mt.h
index 6c95b6ed58..1890f7b760 100644
--- a/servers/visual/visual_server_wrap_mt.h
+++ b/servers/visual/visual_server_wrap_mt.h
@@ -1139,14 +1139,9 @@ public:
 	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_material,RID, 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&);
+	FUNC2(canvas_item_set_use_parent_material,RID, bool );
 
 	FUNC1(canvas_item_clear,RID);
 	FUNC1(canvas_item_raise,RID);
@@ -1167,14 +1162,31 @@ public:
 	FUNC2(canvas_light_set_subtract_mode,RID,bool);
 	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);
+	FUNC2(canvas_light_set_shadow_esm_multiplier,RID,float);
+
 
 	/* 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>&);
+	FUNC2(canvas_light_occluder_set_polygon,RID,RID);
+	FUNC2(canvas_light_occluder_set_transform,RID,const Matrix32&);
+	FUNC2(canvas_light_occluder_set_light_mask,RID,int);
+
+
+	FUNC0R(RID,canvas_occluder_polygon_create);
+	FUNC3(canvas_occluder_polygon_set_shape,RID,const DVector<Vector2>&,bool);
+	FUNC2(canvas_occluder_polygon_set_shape_as_lines,RID,const DVector<Vector2>&);
+	FUNC2(canvas_occluder_polygon_set_cull_mode,RID,CanvasOccluderPolygonCullMode);
+
+	/* CANVAS MATERIAL */
+
+	FUNC0R(RID,canvas_item_material_create);
+	FUNC2(canvas_item_material_set_shader,RID,RID);
+	FUNC3(canvas_item_material_set_shader_param,RID,const StringName&,const Variant&);
+	FUNC2RC(Variant,canvas_item_material_get_shader_param,RID,const StringName&);
+	FUNC2(canvas_item_material_set_unshaded,RID,bool);
 
 	/* CURSOR */
 	FUNC2(cursor_set_rotation,float , int ); // radians
diff --git a/servers/visual_server.h b/servers/visual_server.h
index 37368e32f4..ccf6978ae3 100644
--- a/servers/visual_server.h
+++ b/servers/visual_server.h
@@ -998,13 +998,9 @@ public:
 	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_material(RID p_item, RID p_material)=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 void canvas_item_set_use_parent_material(RID p_item, bool p_enable)=0;
 
 	virtual RID canvas_light_create()=0;
 	virtual void canvas_light_attach_to_canvas(RID p_light,RID p_canvas)=0;
@@ -1021,13 +1017,34 @@ public:
 	virtual void canvas_light_set_subtract_mode(RID p_light, bool p_enable)=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 void canvas_light_set_shadow_esm_multiplier(RID p_light, float p_multiplier)=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;
+	virtual void canvas_light_occluder_set_polygon(RID p_occluder,RID p_polygon)=0;
+	virtual void canvas_light_occluder_set_transform(RID p_occluder,const Matrix32& p_xform)=0;
+	virtual void canvas_light_occluder_set_light_mask(RID p_occluder,int p_mask)=0;
+
+	virtual RID canvas_occluder_polygon_create()=0;
+	virtual void canvas_occluder_polygon_set_shape(RID p_occluder_polygon,const DVector<Vector2>& p_shape,bool p_closed)=0;
+	virtual void canvas_occluder_polygon_set_shape_as_lines(RID p_occluder_polygon,const DVector<Vector2>& p_shape)=0;
+	enum CanvasOccluderPolygonCullMode {
+		CANVAS_OCCLUDER_POLYGON_CULL_DISABLED,
+		CANVAS_OCCLUDER_POLYGON_CULL_CLOCKWISE,
+		CANVAS_OCCLUDER_POLYGON_CULL_COUNTER_CLOCKWISE,
+	};
+	virtual void canvas_occluder_polygon_set_cull_mode(RID p_occluder_polygon,CanvasOccluderPolygonCullMode p_mode)=0;
+
+	/* CANVAS ITEM MATERIAL */
+
+	virtual RID canvas_item_material_create()=0;
+	virtual void canvas_item_material_set_shader(RID p_material, RID p_shader)=0;
+	virtual void canvas_item_material_set_shader_param(RID p_material, const StringName& p_param, const Variant& p_value)=0;
+	virtual Variant canvas_item_material_get_shader_param(RID p_material, const StringName& p_param) const=0;
+	virtual void canvas_item_material_set_unshaded(RID p_material, bool p_unshaded)=0;
 
 	/* CURSOR */
 	virtual void cursor_set_rotation(float p_rotation, int p_cursor = 0)=0; // radians
diff --git a/tools/editor/editor_node.cpp b/tools/editor/editor_node.cpp
index cc1a05f7d3..3d42867d9a 100644
--- a/tools/editor/editor_node.cpp
+++ b/tools/editor/editor_node.cpp
@@ -90,6 +90,7 @@
 #include "plugins/baked_light_editor_plugin.h"
 #include "plugins/polygon_2d_editor_plugin.h"
 #include "plugins/navigation_polygon_editor_plugin.h"
+#include "plugins/light_occluder_2d_editor_plugin.h"
 // end
 #include "tools/editor/io_plugins/editor_texture_import_plugin.h"
 #include "tools/editor/io_plugins/editor_scene_import_plugin.h"
@@ -4115,6 +4116,7 @@ EditorNode::EditorNode() {
 	add_editor_plugin( memnew( PathEditorPlugin(this) ) );
 	add_editor_plugin( memnew( BakedLightEditorPlugin(this) ) );
 	add_editor_plugin( memnew( Polygon2DEditorPlugin(this) ) );
+	add_editor_plugin( memnew( LightOccluder2DEditorPlugin(this) ) );
 	add_editor_plugin( memnew( NavigationPolygonEditorPlugin(this) ) );
 
 	for(int i=0;i<EditorPlugins::get_plugin_count();i++)
diff --git a/tools/editor/icons/icon_canvas_item_material.png b/tools/editor/icons/icon_canvas_item_material.png
new file mode 100644
index 0000000000000000000000000000000000000000..2fe892165358edd2a2eed4c377f1a15238518995
GIT binary patch
literal 835
zcmeAS@N?(olHy`uVBq!ia0y~yU=RRd4mJh`2Kmqb6B!s7*pj^6T^PXNr}OT51_lPs
z0*}aI1_o|n5N2eUHAjMhfq}im)7O>#J~N{j1M7}NqeTo146>Oa5hc#~xw)x%C1Cx|
zMX8A;sVNHOnI#zt?w-B@DSD~w3=B-mJzX3_EKZjOdwYZgO8h%#`~2Kq<HhAQJ;`Bi
zc1+=pdLkE_1Qsr0DqMI$>jk4|m%tXzmKCiJ)H<DnZ?P*%dI;)naWR>pBtG+*a*gRZ
z*}0PGd%mB$Q|!-u`IDjjoU{M`{{KGz^W699Cj>tK^`8+Hp~l!CIjgYG{N6_XRms)D
zojY7No3zdr+&k~7%xV?}<3;R@d%TbM&RV+i&;P1T(-VFrhp&ES|I<Q-OL<v)4#SC$
z;zsog7(SlZzD;=f`?7SE88d5s&AId_J9$3a!!qL)tC$!Je7V~W2F8}l&C&ldHT2G|
zeccb9zY?Do^S>apF!T#w|9;1P_t{-j7lbe|6udiNl<V?E;#^2<)6`je9-duWA1G&$
z`u>i>4hw~Qef!+Q=1J$R=bqxJkisqI)Nq@xCxxril=*p<R6ykyBSwa6KOYOmnoY}E
zw%Bux7E7B}b0C-Jq%zwp3t6^lB|94$%K9#P`}*y!!|#+AuL-g9?p_(Yca46b>h38`
zD+^S(HoC_vayArd+*F$;^k8e_v@Exq7Qbz*`57xDrdkG{(pbpT;_>_6Y=MRVb{|jW
zDJDDY_CFHrV_v5I$wlf?&cyCrDXQ#2QKz2h<|r~{X5Za9;n8Lz8ON=k#CU9ygF~0j
z{%-51Cm`y;BiX-2F|pXu-G6$G>*Y&k(p41~8552zi{n2%F=OlPwVJ=*Zq;Skkm<5E
z!lfs1(LtG6KVCQAnp9_GG~N5%U7q6lIKgmHeNh2xH$est4j=84U$=_hx*6<{?S1X&
ziI~MVW?rp&IQ8`J+d)iIP2OGI^ftzS-;y06oD6HGymT>F_EXw-@Q~v=RX)wI?+L-L
z=Ib%+VxJvkX?HW@eYV=YfIWw2%#MlqFM8xwjli=z-(AZ!?p?fh-KWOx=8e2_5_|dM
h-rc@5kGY891N-?nc{__K{q3N{?CI*~vd$@?2>`eMU4j4r

literal 0
HcmV?d00001

diff --git a/tools/editor/icons/icon_canvas_modulate.png b/tools/editor/icons/icon_canvas_modulate.png
new file mode 100644
index 0000000000000000000000000000000000000000..2a34df7793a438c07a737ebe3595eaed315894f5
GIT binary patch
literal 441
zcmeAS@N?(olHy`uVBq!ia0y~yU=RRd4mJh`2Kmqb6B!s7*pj^6T^PXNr}OT51_lPs
z0*}aI1_o|n5N2eUHAjMhfq}im)7O>#J~N}ZFz3Zzp*jo<jBcJTjv*GOlM^H|4s>`w
z+Hbj-Kjz}e|Ir>s43Wl)&JhKfb;};<{E0djGpVt$(eca0lh6N4e*2YR+`>BhS@F8w
zU;L%cO?5?_+QtS326v1rs>A=Cy7l$H<ST=iriV>;)Wijw>lGd6@Jw<u*!aF?lH2pI
z!4l8*Z>~90aEaB`R@g{=%~Sj45B1)jWo#X1Pc+PJ_Kl42^5`=BwV%I?`JeHRHDw3o
zQ_XLfC@^-Va0vSt`#f0o;Nx?9$$R%w6B2&(%h=qn|FgIHv*_vKiZu?riB8*7TW`KI
z|1END-TyED@3z|iudn~}`TzIh-+ScsWU7vA{`biEnmNnjiH(hoi8I~awrc19v%B_V
zvDV202M!c;KRwsoo&NgX1Ah;XdkxK#7Yeve4o_6uwzMZYVDEtw4Kpvb%rh{!v+=-6
o$?71tGR`XjPXgSp`G_(wT%J^W-=(VeCMXI#UHx3vIVCg!0RBS11ONa4

literal 0
HcmV?d00001

diff --git a/tools/editor/icons/icon_light_occluder_2d.png b/tools/editor/icons/icon_light_occluder_2d.png
new file mode 100644
index 0000000000000000000000000000000000000000..c66dd536d3d5f22364053d459559ee3a2565eb41
GIT binary patch
literal 516
zcmeAS@N?(olHy`uVBq!ia0y~yU=RRd4mJh`2Kmqb6B!s7*pj^6T^PXNr}OT51_lPs
z0*}aI1_o|n5N2eUHAjMhfq}im)7O>#J~N}Jltd<v)K3Nm#)+OTjv*GO-%dX09g-+=
z^nC68+Rqhx&FxwX4bqJtJXv*CL2|8e=dIMWceaTv3|sov==RU}9Xv6v7LmHlhK4Fj
z4z&udzZkMbGw0sleYf2l3*0)l&As}x$nwtTX68SOUu0Bl{qp(Z?yJXoy)0u4<Z@Og
z7p6?|Sii6CcE!JnHRW6kFWx<=QkdyiF5djx<+x1rikX_HRORn)W6k_k-8NHg$9^G4
z7vGH!m{}~Y-*a%e7;Iqn^32SdGi|($+1$~R)id^*+z9o0?fc&S@Hy+{mrgDC7hCrJ
z&YP-jzdk19{Vh%oYwTHl)lckV_D`F5e&=tT5_!`X&s?b{yYH>`<qJD6=onq*ikI_n
zamn`dxmsfU*~@lk<@v?a<WrdXn9Osg#;i17!)hs1_p#{obRYNK-3N1-Hhg<|eeGt2
zYvnqZzC6%2-us-pR?tPHo;}c4M)FU41;@tyLe4I^8xJrrEPtyQwc4Vd!%%*6YO&7i
zJG1w;C;OYp&ADb%`upUkTl;$K{~DDp>P^pld3YXU!BMLoo;aU(vTy%0Ji7lmqbB4Q
Q6DT%4UHx3vIVCg!0KW&|4FCWD

literal 0
HcmV?d00001

diff --git a/tools/editor/icons/icon_occluder_polygon_2d.png b/tools/editor/icons/icon_occluder_polygon_2d.png
new file mode 100644
index 0000000000000000000000000000000000000000..705794b729c7f91db87eb3567767e2507fe20c74
GIT binary patch
literal 581
zcmeAS@N?(olHy`uVBq!ia0y~yU=RRd4mJh`2Kmqb6B!s7*pj^6T^PXNr}OT51_lPs
z0*}aI1_s{iAk65bF}s3+fq}im)7O>#J~N}Jj0KCu-0chujF&uJ978NlpPgiz9TF(e
zHh;Ht%t_rn+_U8q6d65}pT~P7E^c*Nq{7wYq11BMPg|SWtVv8P>P6PW@SRIL{;~8n
zF6h3oqBD;3$>BG1zi-{K`zA+|rfq@6`#Hv+&lnUx*dOzJw*IBRzrxrS-933ZU4Q$!
zxP8|OnRFXwwl06Uk1=@i*WR^j-@X<WcJJ(Xmh*Y%#%PAi#r&7*nHVOqY|>F)ou0{b
zBWvF5`ke2M%k}U1{^!al|HS;(uTJ_#567|N{TH;WZuq4(-nA)yInS5V%CcJfFSCJZ
z<bB3I=B+B8CpPs|m2n7IOqd$QSoZl!tM#_4OcsWv$tE{1yYO$xy>|V2<>z0b3_%Mt
zCUC7$Saf5<6t_1ql9}b7q&9HmFfC^GSbTB8MTz9xx6&3HLi0G^gzz;S6<oko!?0@G
z%COacP83hOw>S0cYjG{n2`xG~-~AmkuTOIPIn}Gx=Ksl0zg73GU+d%)S;kVNAi9F%
zO;f;>?^-MF?b$!4%)ahb>F&G9+S=Oe^||@Yz3h>p3aoE#IdS<sFxc%oC$i$x&903d
zi_~2016)LQ3%orU6Bfq9$Z+{{|C@u0fAw+Q;pgHnwVW#P@5tt2{%p>piQb3%q7@$g
f6Zw{P`^F=4skD+z?iD6hpyc4`>gTe~DWM4fhmZG=

literal 0
HcmV?d00001

diff --git a/tools/editor/plugins/collision_polygon_2d_editor_plugin.cpp b/tools/editor/plugins/collision_polygon_2d_editor_plugin.cpp
index ed228e9a1c..dab6df9a39 100644
--- a/tools/editor/plugins/collision_polygon_2d_editor_plugin.cpp
+++ b/tools/editor/plugins/collision_polygon_2d_editor_plugin.cpp
@@ -4,6 +4,7 @@
 #include "os/file_access.h"
 #include "tools/editor/editor_settings.h"
 
+
 void CollisionPolygon2DEditor::_notification(int p_what) {
 
 	switch(p_what) {
diff --git a/tools/editor/plugins/light_occluder_2d_editor_plugin.cpp b/tools/editor/plugins/light_occluder_2d_editor_plugin.cpp
new file mode 100644
index 0000000000..c1fb81b66a
--- /dev/null
+++ b/tools/editor/plugins/light_occluder_2d_editor_plugin.cpp
@@ -0,0 +1,500 @@
+#include "light_occluder_2d_editor_plugin.h"
+
+#include "canvas_item_editor_plugin.h"
+#include "os/file_access.h"
+#include "tools/editor/editor_settings.h"
+
+void LightOccluder2DEditor::_notification(int p_what) {
+
+	switch(p_what) {
+
+		case NOTIFICATION_READY: {
+
+			button_create->set_icon( get_icon("Edit","EditorIcons"));
+			button_edit->set_icon( get_icon("MovePoint","EditorIcons"));
+			button_edit->set_pressed(true);
+			get_tree()->connect("node_removed",this,"_node_removed");
+			create_poly->connect("confirmed",this,"_create_poly");
+
+		} break;
+		case NOTIFICATION_FIXED_PROCESS: {
+
+
+		} break;
+	}
+
+}
+void LightOccluder2DEditor::_node_removed(Node *p_node) {
+
+	if(p_node==node) {
+		node=NULL;
+		hide();
+		canvas_item_editor->get_viewport_control()->update();
+	}
+
+}
+
+
+Vector2 LightOccluder2DEditor::snap_point(const Vector2& p_point) const {
+
+	if (canvas_item_editor->is_snap_active()) {
+
+		return p_point.snapped(Vector2(1,1)*canvas_item_editor->get_snap());
+
+	} else {
+		return p_point;
+	}
+}
+
+void LightOccluder2DEditor::_menu_option(int p_option) {
+
+	switch(p_option) {
+
+		case MODE_CREATE: {
+
+			mode=MODE_CREATE;
+			button_create->set_pressed(true);
+			button_edit->set_pressed(false);
+		} break;
+		case MODE_EDIT: {
+
+			mode=MODE_EDIT;
+			button_create->set_pressed(false);
+			button_edit->set_pressed(true);
+		} break;
+
+	}
+}
+
+void LightOccluder2DEditor::_wip_close(bool p_closed) {
+
+	undo_redo->create_action("Create Poly");
+	undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",node->get_occluder_polygon()->get_polygon());
+	undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",wip);
+	undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_closed",node->get_occluder_polygon()->is_closed());
+	undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_closed",p_closed);
+
+	undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+	undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+	undo_redo->commit_action();
+	wip.clear();
+	wip_active=false;
+	mode=MODE_EDIT;
+	button_edit->set_pressed(true);
+	button_create->set_pressed(false);
+	edited_point=-1;
+}
+
+bool LightOccluder2DEditor::forward_input_event(const InputEvent& p_event) {
+
+
+	if (!node)
+		return false;
+
+	if (node->get_occluder_polygon().is_null()) {
+		if (p_event.type==InputEvent::MOUSE_BUTTON && p_event.mouse_button.button_index==1 && p_event.mouse_button.pressed) {
+			create_poly->set_text("No OccluderPolygon2D resource on this node.\nCreate and assign one?");
+			create_poly->popup_centered_minsize();
+		}
+		return false;
+	}
+	switch(p_event.type) {
+
+		case InputEvent::MOUSE_BUTTON: {
+
+			const InputEventMouseButton &mb=p_event.mouse_button;
+
+			Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
+
+
+			Vector2 gpoint = Point2(mb.x,mb.y);
+			Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
+			cpoint=snap_point(cpoint);
+			cpoint = node->get_global_transform().affine_inverse().xform(cpoint);
+
+			Vector<Vector2> poly = Variant(node->get_occluder_polygon()->get_polygon());
+
+			//first check if a point is to be added (segment split)
+			real_t grab_treshold=EDITOR_DEF("poly_editor/point_grab_radius",8);
+
+			switch(mode) {
+
+
+				case MODE_CREATE: {
+
+					if (mb.button_index==BUTTON_LEFT && mb.pressed) {
+
+
+						if (!wip_active) {
+
+							wip.clear();
+							wip.push_back( cpoint );
+							wip_active=true;
+							edited_point_pos=cpoint;
+							canvas_item_editor->get_viewport_control()->update();
+							edited_point=1;
+							return true;
+						} else {
+
+
+							if (wip.size()>1 && xform.xform(wip[0]).distance_to(gpoint)<grab_treshold) {
+								//wip closed
+								_wip_close(true);
+
+								return true;
+							} else if (wip.size()>1 && xform.xform(wip[wip.size()-1]).distance_to(gpoint)<grab_treshold) {
+									//wip closed
+									_wip_close(false);
+									return true;
+
+							} else {
+
+								wip.push_back( cpoint );
+								edited_point=wip.size();
+								canvas_item_editor->get_viewport_control()->update();
+								return true;
+
+								//add wip point
+							}
+						}
+					} else if (mb.button_index==BUTTON_RIGHT && mb.pressed && wip_active) {
+						_wip_close(true);
+					}
+
+
+
+				} break;
+
+				case MODE_EDIT: {
+
+					if (mb.button_index==BUTTON_LEFT) {
+						if (mb.pressed) {
+
+							if (mb.mod.control) {
+
+
+								if (poly.size() < 3) {
+
+									undo_redo->create_action("Edit Poly");
+									undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+									poly.push_back(cpoint);
+									undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+									undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+									undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+									undo_redo->commit_action();
+									return true;
+								}
+
+								//search edges
+								int closest_idx=-1;
+								Vector2 closest_pos;
+								real_t closest_dist=1e10;
+								for(int i=0;i<poly.size();i++) {
+
+									Vector2 points[2] ={ xform.xform(poly[i]),
+										xform.xform(poly[(i+1)%poly.size()]) };
+
+									Vector2 cp = Geometry::get_closest_point_to_segment_2d(gpoint,points);
+									if (cp.distance_squared_to(points[0])<CMP_EPSILON2 || cp.distance_squared_to(points[1])<CMP_EPSILON2)
+										continue; //not valid to reuse point
+
+									real_t d = cp.distance_to(gpoint);
+									if (d<closest_dist && d<grab_treshold) {
+										closest_dist=d;
+										closest_pos=cp;
+										closest_idx=i;
+									}
+
+
+								}
+
+								if (closest_idx>=0) {
+
+									pre_move_edit=poly;
+									poly.insert(closest_idx+1,xform.affine_inverse().xform(closest_pos));
+									edited_point=closest_idx+1;
+									edited_point_pos=xform.affine_inverse().xform(closest_pos);
+									node->get_occluder_polygon()->set_polygon(Variant(poly));
+									canvas_item_editor->get_viewport_control()->update();
+									return true;
+								}
+							} else {
+
+								//look for points to move
+
+								int closest_idx=-1;
+								Vector2 closest_pos;
+								real_t closest_dist=1e10;
+								for(int i=0;i<poly.size();i++) {
+
+									Vector2 cp =xform.xform(poly[i]);
+
+									real_t d = cp.distance_to(gpoint);
+									if (d<closest_dist && d<grab_treshold) {
+										closest_dist=d;
+										closest_pos=cp;
+										closest_idx=i;
+									}
+
+								}
+
+								if (closest_idx>=0) {
+
+									pre_move_edit=poly;
+									edited_point=closest_idx;
+									edited_point_pos=xform.affine_inverse().xform(closest_pos);
+									canvas_item_editor->get_viewport_control()->update();
+									return true;
+								}
+							}
+						} else {
+
+							if (edited_point!=-1) {
+
+								//apply
+
+								ERR_FAIL_INDEX_V(edited_point,poly.size(),false);
+								poly[edited_point]=edited_point_pos;
+								undo_redo->create_action("Edit Poly");
+								undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+								undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",pre_move_edit);
+								undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+								undo_redo->commit_action();
+
+								edited_point=-1;
+								return true;
+							}
+						}
+					} if (mb.button_index==BUTTON_RIGHT && mb.pressed && edited_point==-1) {
+
+
+
+						int closest_idx=-1;
+						Vector2 closest_pos;
+						real_t closest_dist=1e10;
+						for(int i=0;i<poly.size();i++) {
+
+							Vector2 cp =xform.xform(poly[i]);
+
+							real_t d = cp.distance_to(gpoint);
+							if (d<closest_dist && d<grab_treshold) {
+								closest_dist=d;
+								closest_pos=cp;
+								closest_idx=i;
+							}
+
+						}
+
+						if (closest_idx>=0) {
+
+
+							undo_redo->create_action("Edit Poly (Remove Point)");
+							undo_redo->add_undo_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+							poly.remove(closest_idx);
+							undo_redo->add_do_method(node->get_occluder_polygon().ptr(),"set_polygon",poly);
+							undo_redo->add_do_method(canvas_item_editor->get_viewport_control(),"update");
+							undo_redo->add_undo_method(canvas_item_editor->get_viewport_control(),"update");
+							undo_redo->commit_action();
+							return true;
+						}
+
+					}
+
+
+
+				} break;
+			}
+
+
+
+		} break;
+		case InputEvent::MOUSE_MOTION: {
+
+			const InputEventMouseMotion &mm=p_event.mouse_motion;
+
+			if (edited_point!=-1 && (wip_active || mm.button_mask&BUTTON_MASK_LEFT)) {
+
+				Vector2 gpoint = Point2(mm.x,mm.y);
+				Vector2 cpoint = canvas_item_editor->get_canvas_transform().affine_inverse().xform(gpoint);
+				cpoint=snap_point(cpoint);
+				edited_point_pos = node->get_global_transform().affine_inverse().xform(cpoint);
+
+				canvas_item_editor->get_viewport_control()->update();
+
+			}
+
+		} break;
+	}
+
+	return false;
+}
+void LightOccluder2DEditor::_canvas_draw() {
+
+	if (!node || !node->get_occluder_polygon().is_valid())
+		return;
+
+	Control *vpc = canvas_item_editor->get_viewport_control();
+
+	Vector<Vector2> poly;
+
+	if (wip_active)
+		poly=wip;
+	else
+		poly=Variant(node->get_occluder_polygon()->get_polygon());
+
+
+	Matrix32 xform = canvas_item_editor->get_canvas_transform() * node->get_global_transform();
+	Ref<Texture> handle= get_icon("EditorHandle","EditorIcons");
+
+	int len = poly.size();
+
+	for(int i=0;i<poly.size();i++) {
+
+
+		Vector2 p,p2;
+		p = i==edited_point ? edited_point_pos : poly[i];
+		if ((wip_active && i==poly.size()-1) || (((i+1)%poly.size())==edited_point))
+			p2=edited_point_pos;
+		else
+			p2 = poly[(i+1)%poly.size()];
+
+		Vector2 point = xform.xform(p);
+		Vector2 next_point = xform.xform(p2);
+
+		Color col=Color(1,0.3,0.1,0.8);
+
+		if (i==poly.size()-1 && (!node->get_occluder_polygon()->is_closed() || wip_active)) {
+
+		} else {
+			vpc->draw_line(point,next_point,col,2);
+		}
+		vpc->draw_texture(handle,point-handle->get_size()*0.5);
+	}
+}
+
+
+
+void LightOccluder2DEditor::edit(Node *p_collision_polygon) {
+
+	if (!canvas_item_editor) {
+		canvas_item_editor=CanvasItemEditor::get_singleton();
+	}
+
+	if (p_collision_polygon) {
+
+		node=p_collision_polygon->cast_to<LightOccluder2D>();
+		if (!canvas_item_editor->get_viewport_control()->is_connected("draw",this,"_canvas_draw"))
+			canvas_item_editor->get_viewport_control()->connect("draw",this,"_canvas_draw");
+		wip.clear();
+		wip_active=false;
+		edited_point=-1;
+
+	} else {
+		node=NULL;
+
+		if (canvas_item_editor->get_viewport_control()->is_connected("draw",this,"_canvas_draw"))
+			canvas_item_editor->get_viewport_control()->disconnect("draw",this,"_canvas_draw");
+
+	}
+
+}
+
+void LightOccluder2DEditor::_create_poly()  {
+
+	undo_redo->create_action("Create Occluder Polygon");
+	undo_redo->add_do_method(node,"set_occluder_polygon",Ref<OccluderPolygon2D>(memnew( OccluderPolygon2D)));
+	undo_redo->add_undo_method(node,"set_occluder_polygon",Variant(REF()));
+	undo_redo->commit_action();
+}
+
+void LightOccluder2DEditor::_bind_methods() {
+
+	ObjectTypeDB::bind_method(_MD("_menu_option"),&LightOccluder2DEditor::_menu_option);
+	ObjectTypeDB::bind_method(_MD("_canvas_draw"),&LightOccluder2DEditor::_canvas_draw);
+	ObjectTypeDB::bind_method(_MD("_node_removed"),&LightOccluder2DEditor::_node_removed);
+	ObjectTypeDB::bind_method(_MD("_create_poly"),&LightOccluder2DEditor::_create_poly);
+
+}
+
+
+LightOccluder2DEditor::LightOccluder2DEditor(EditorNode *p_editor) {
+
+	canvas_item_editor=NULL;
+	editor=p_editor;
+	undo_redo = editor->get_undo_redo();
+
+	add_child( memnew( VSeparator ));
+	button_create = memnew( ToolButton );
+	add_child(button_create);
+	button_create->connect("pressed",this,"_menu_option",varray(MODE_CREATE));
+	button_create->set_toggle_mode(true);
+	button_create->set_tooltip("Create a new polygon from scratch");
+
+	button_edit = memnew( ToolButton );
+	add_child(button_edit);
+	button_edit->connect("pressed",this,"_menu_option",varray(MODE_EDIT));
+	button_edit->set_toggle_mode(true);
+	button_edit->set_tooltip("Edit existing polygon:\nLMB: Move Point.\nCtrl+LMB: Split Segment.\nRMB: Erase Point.");
+
+	create_poly = memnew( ConfirmationDialog );
+	add_child(create_poly);
+	create_poly->get_ok()->set_text("Create");
+
+
+	//add_constant_override("separation",0);
+
+#if 0
+	options = memnew( MenuButton );
+	add_child(options);
+	options->set_area_as_parent_rect();
+	options->set_text("Polygon");
+	//options->get_popup()->add_item("Parse BBCODE",PARSE_BBCODE);
+	options->get_popup()->connect("item_pressed", this,"_menu_option");
+#endif
+
+	mode = MODE_EDIT;
+	wip_active=false;
+
+}
+
+
+void LightOccluder2DEditorPlugin::edit(Object *p_object) {
+
+	collision_polygon_editor->edit(p_object->cast_to<Node>());
+}
+
+bool LightOccluder2DEditorPlugin::handles(Object *p_object) const {
+
+	return p_object->is_type("LightOccluder2D");
+}
+
+void LightOccluder2DEditorPlugin::make_visible(bool p_visible) {
+
+	if (p_visible) {
+		collision_polygon_editor->show();
+	} else {
+
+		collision_polygon_editor->hide();
+		collision_polygon_editor->edit(NULL);
+	}
+
+}
+
+LightOccluder2DEditorPlugin::LightOccluder2DEditorPlugin(EditorNode *p_node) {
+
+	editor=p_node;
+	collision_polygon_editor = memnew( LightOccluder2DEditor(p_node) );
+	CanvasItemEditor::get_singleton()->add_control_to_menu_panel(collision_polygon_editor);
+
+	collision_polygon_editor->hide();
+
+
+
+}
+
+
+LightOccluder2DEditorPlugin::~LightOccluder2DEditorPlugin()
+{
+}
+
diff --git a/tools/editor/plugins/light_occluder_2d_editor_plugin.h b/tools/editor/plugins/light_occluder_2d_editor_plugin.h
new file mode 100644
index 0000000000..5fb5631d05
--- /dev/null
+++ b/tools/editor/plugins/light_occluder_2d_editor_plugin.h
@@ -0,0 +1,87 @@
+#ifndef LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H
+#define LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H
+
+
+
+#include "tools/editor/editor_plugin.h"
+#include "tools/editor/editor_node.h"
+#include "scene/2d/light_occluder_2d.h"
+#include "scene/gui/tool_button.h"
+#include "scene/gui/button_group.h"
+
+/**
+	@author Juan Linietsky <reduzio@gmail.com>
+*/
+class CanvasItemEditor;
+
+class LightOccluder2DEditor : public HBoxContainer {
+
+	OBJ_TYPE(LightOccluder2DEditor, HBoxContainer );
+
+	UndoRedo *undo_redo;
+	enum Mode {
+
+		MODE_CREATE,
+		MODE_EDIT,
+
+	};
+
+	Mode mode;
+
+	ToolButton *button_create;
+	ToolButton *button_edit;
+
+	CanvasItemEditor *canvas_item_editor;
+	EditorNode *editor;
+	Panel *panel;
+	LightOccluder2D *node;
+	MenuButton *options;
+
+	int edited_point;
+	Vector2 edited_point_pos;
+	Vector<Vector2> pre_move_edit;
+	Vector<Vector2> wip;
+	bool wip_active;
+
+	ConfirmationDialog *create_poly;
+
+	void _wip_close(bool p_closed);
+	void _canvas_draw();
+	void _menu_option(int p_option);
+	void _create_poly();
+
+protected:
+	void _notification(int p_what);
+	void _node_removed(Node *p_node);
+	static void _bind_methods();
+public:
+
+	Vector2 snap_point(const Vector2& p_point) const;
+	bool forward_input_event(const InputEvent& p_event);
+	void edit(Node *p_collision_polygon);
+	LightOccluder2DEditor(EditorNode *p_editor);
+};
+
+class LightOccluder2DEditorPlugin : public EditorPlugin {
+
+	OBJ_TYPE( LightOccluder2DEditorPlugin, EditorPlugin );
+
+	LightOccluder2DEditor *collision_polygon_editor;
+	EditorNode *editor;
+
+public:
+
+	virtual bool forward_input_event(const InputEvent& p_event) { return collision_polygon_editor->forward_input_event(p_event); }
+
+	virtual String get_name() const { return "LightOccluder2D"; }
+	bool has_main_screen() const { return false; }
+	virtual void edit(Object *p_node);
+	virtual bool handles(Object *p_node) const;
+	virtual void make_visible(bool p_visible);
+
+	LightOccluder2DEditorPlugin(EditorNode *p_node);
+	~LightOccluder2DEditorPlugin();
+
+};
+
+#endif // LIGHT_OCCLUDER_2D_EDITOR_PLUGIN_H
diff --git a/tools/editor/property_editor.cpp b/tools/editor/property_editor.cpp
index a600683097..25c39b3173 100644
--- a/tools/editor/property_editor.cpp
+++ b/tools/editor/property_editor.cpp
@@ -1857,8 +1857,33 @@ void PropertyEditor::set_item_text(TreeItem *p_item, int p_type, const String& p
 				} else {
 					p_item->set_text(1,"<"+res->get_type()+">");
 				};
+
+				if (has_icon(res->get_type(),"EditorIcons")) {
+
+					p_item->set_icon(1,get_icon(res->get_type(),"EditorIcons"));
+				} else {
+
+					Dictionary d = p_item->get_metadata(0);
+					int hint=d.has("hint")?d["hint"].operator int():-1;
+					String hint_text=d.has("hint_text")?d["hint_text"]:"";
+					if (hint==PROPERTY_HINT_RESOURCE_TYPE) {
+
+						if (has_icon(hint_text,"EditorIcons")) {
+
+							p_item->set_icon(1,get_icon(hint_text,"EditorIcons"));
+
+						} else {
+							p_item->set_icon(1,get_icon("Object","EditorIcons"));
+
+						}
+					}
+				}
+
+
+
 			}
 
+
 		} break;
 		default: {};
 	}
@@ -2529,7 +2554,10 @@ void PropertyEditor::update_tree() {
 				item->set_editable( 1, !read_only );
 				item->add_button(1,get_icon("EditResource","EditorIcons"));
 				String type;
+				if (p.hint==PROPERTY_HINT_RESOURCE_TYPE)
+					type=p.hint_string;
 				bool notnil=false;
+
 				if (obj->get( p.name ).get_type() == Variant::NIL || obj->get( p.name ).operator RefPtr().is_null()) {
 					item->set_text(1,"<null>");
 
@@ -2553,12 +2581,18 @@ void PropertyEditor::update_tree() {
 					};
 					notnil=true;
 
+					if (has_icon(res->get_type(),"EditorIcons")) {
+						type=res->get_type();
+					}
 				}
 
-				if (p.hint==PROPERTY_HINT_RESOURCE_TYPE) {
+
+				if (type!=String()) {
+					if (type.find(",")!=-1)
+						type=type.get_slice(",",0);
 					//printf("prop %s , type %s\n",p.name.ascii().get_data(),p.hint_string.ascii().get_data());
-					if (has_icon(p.hint_string,"EditorIcons"))
-						item->set_icon( 0, get_icon(p.hint_string,"EditorIcons") );
+					if (has_icon(type,"EditorIcons"))
+						item->set_icon( 0, get_icon(type,"EditorIcons") );
 					else
 						item->set_icon( 0, get_icon("Object","EditorIcons") );
 				}