Merge branch 'master' of https://github.com/not-surt/godot into snapping2

Conflicts:
	tools/editor/plugins/canvas_item_editor_plugin.cpp
	tools/editor/plugins/canvas_item_editor_plugin.h

3 files changed, 199 insertions, 21 deletions

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..e6d2569977 100644
--- a/drivers/gles2/shaders/canvas.glsl
+++ b/drivers/gles2/shaders/canvas.glsl
@@ -26,6 +26,7 @@ uniform float time;
 #ifdef USE_LIGHTING
 
 uniform highp mat4 light_matrix;
+uniform highp mat4 light_local_matrix;
 uniform vec2 light_pos;
 varying vec4 light_uv_interp;
 
@@ -34,6 +35,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 +68,8 @@ VERTEX_SHADER_CODE
         outvec = modelview_matrix * outvec;
 #endif
 
+
+
 #ifdef USE_PIXEL_SNAP
 
 	outvec.xy=floor(outvec.xy+0.5);
@@ -74,7 +81,10 @@ VERTEX_SHADER_CODE
 #ifdef USE_LIGHTING
 
 	light_uv_interp.xy = (light_matrix * outvec).xy;
-	light_uv_interp.zw = outvec.xy-light_pos;
+	light_uv_interp.zw =(light_local_matrix * outvec).xy;
+#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 +164,14 @@ varying vec4 local_rot;
 uniform sampler2D shadow_texture;
 uniform float shadow_attenuation;
 
+uniform highp mat4 shadow_matrix;
+highp varying vec2 pos;
+uniform float shadowpixel_size;
+
+#ifdef SHADOW_ESM
+uniform float shadow_esm_multiplier;
+#endif
+
 #endif
 
 #endif
@@ -170,19 +188,24 @@ void main() {
 
 	vec4 color = color_interp;
 #if defined(NORMAL_USED)
-	vec3 normal = vec3(0,0,1);
+	vec3 normal = vec3(0.0,0.0,1.0);
 #endif
 
-#ifdef USE_MODULATE
+#ifdef USE_DISTANCE_FIELD
+	const float smoothing = 1.0/32.0;
+	float distance = texture2D(texture, uv_interp).a;
+	color.a = smoothstep(0.5 - smoothing, 0.5 + smoothing, distance);
+#else
+	color *= texture2D( texture,  uv_interp );
 
-	color*=modulate;
 #endif
 
-	color *= texture2D( texture,  uv_interp );
+
 #if defined(ENABLE_SCREEN_UV)
 	vec2 screen_uv = gl_FragCoord.xy*screen_uv_mult;
 #endif
 
+
 {
 FRAGMENT_SHADER_CODE
 }
@@ -191,39 +214,37 @@ FRAGMENT_SHADER_CODE
 	color = vec4(vec3(enc32),1.0);
 #endif
 
+#ifdef USE_MODULATE
+
+	color*=modulate;
+#endif
+
+
 #ifdef USE_LIGHTING
 
+	vec2 light_vec = light_uv_interp.zw;; //for shadow and normal mapping
+
 #if defined(NORMAL_USED)
 	normal.xy =  mat2(local_rot.xy,local_rot.zw) * normal.xy;
 #endif
 
 	float att=1.0;
 
-	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;
-	}
-//use shadows
-#endif
+	vec4 light = texture2D(light_texture,light_uv_interp.xy) * light_color;	
 
 #if defined(USE_LIGHT_SHADER_CODE)
 //light is written by the light shader
 {
-	vec2 light_dir = normalize(light_uv_interp.zw);
-	float light_distance = length(light_uv_interp.zw);
+	vec4 light_out=vec4(0.0,0.0,0.0,0.0);
 LIGHT_SHADER_CODE
+	color=light_out;
 }
 
 #else
 
 #if defined(NORMAL_USED)
-	vec3 light_normal = normalize(vec3(light_uv_interp.zw,-light_height));
-	light*=max(dot(-light_normal,normal),0);
+	vec3 light_normal = normalize(vec3(light_vec,-light_height));
+	light*=max(dot(-light_normal,normal),0.0);
 #endif
 
 	color*=light;
@@ -233,13 +254,107 @@ LIGHT_SHADER_CODE
 	color.zw=vec2(0.0,1.0);
 #endif
 */
+
+//light shader code
+#endif
+
 	if (any(lessThan(light_uv_interp.xy,vec2(0.0,0.0))) || any(greaterThanEqual(light_uv_interp.xy,vec2(1.0,1.0)))) {
 		color.a=0.0; //invisible
+	} else {
+
+#ifdef USE_SHADOWS
+
+		float angle_to_light = -atan(light_vec.x,light_vec.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 = light_vec;
+			sh=0.0+(1.0/8.0);
+		} else if (abs_angle>135.0*PI/180.0) {
+			point = -light_vec;
+			sh = 0.5+(1.0/8.0);
+		} else if (angle_to_light>0.0) {
+
+			point = vec2(light_vec.y,-light_vec.x);
+			sh = 0.25+(1.0/8.0);
+		} else {
+
+			point = vec2(-light_vec.y,light_vec.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);
 	}
 
-//light shader code
 #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
+
+		color.rgb*=shadow_attenuation;
+//use shadows
+#endif
+	}
+
 //use lighting
 #endif
 //	color.rgb*=color.a;
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
+
+}
+