-Rewrote GLES2 lighting and shadows and optimized state changes, did many optimizations, added vertex lighting.

-Did some fixes to GLES3 too

13 files changed, 1889 insertions, 1083 deletions

diff --git a/drivers/gles2/rasterizer_scene_gles2.cpp b/drivers/gles2/rasterizer_scene_gles2.cpp
index ca9f6dcbf8..833b3ef0f7 100644
--- a/drivers/gles2/rasterizer_scene_gles2.cpp
+++ b/drivers/gles2/rasterizer_scene_gles2.cpp
@@ -110,8 +110,8 @@ void RasterizerSceneGLES2::shadow_atlas_set_size(RID p_atlas, int p_size) {
 		glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, shadow_atlas->size, shadow_atlas->size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
 
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
@@ -604,6 +604,8 @@ RID RasterizerSceneGLES2::light_instance_create(RID p_light) {
 	light_instance->light = p_light;
 	light_instance->light_ptr = storage->light_owner.getornull(p_light);
 
+	light_instance->light_index = 0xFFFF;
+
 	ERR_FAIL_COND_V(!light_instance->light_ptr, RID());
 
 	light_instance->self = light_instance_owner.make_rid(light_instance);
@@ -709,9 +711,42 @@ void RasterizerSceneGLES2::_add_geometry_with_material(RasterizerStorageGLES2::G
 	bool has_blend_alpha = p_material->shader->spatial.blend_mode != RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_MIX;
 	bool has_alpha = has_base_alpha || has_blend_alpha;
 
-	// TODO add this stuff
-	// bool mirror = p_instance->mirror;
-	// bool no_cull = false;
+	bool mirror = p_instance->mirror;
+	bool no_cull = false;
+
+	if (p_material->shader->spatial.cull_mode == RasterizerStorageGLES2::Shader::Spatial::CULL_MODE_DISABLED) {
+		no_cull = true;
+		mirror = false;
+	} else if (p_material->shader->spatial.cull_mode == RasterizerStorageGLES2::Shader::Spatial::CULL_MODE_FRONT) {
+		mirror = !mirror;
+	}
+
+	//if (p_material->shader->spatial.uses_sss) {
+	//	state.used_sss = true;
+	//}
+
+	if (p_material->shader->spatial.uses_screen_texture) {
+		state.used_screen_texture = true;
+	}
+
+	if (p_depth_pass) {
+
+		if (has_blend_alpha || p_material->shader->spatial.uses_depth_texture || (has_base_alpha && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES2::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS))
+			return; //bye
+
+		if (!p_material->shader->spatial.uses_alpha_scissor && !p_material->shader->spatial.writes_modelview_or_projection && !p_material->shader->spatial.uses_vertex && !p_material->shader->spatial.uses_discard && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES2::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+			//shader does not use discard and does not write a vertex position, use generic material
+			if (p_instance->cast_shadows == VS::SHADOW_CASTING_SETTING_DOUBLE_SIDED) {
+				p_material = storage->material_owner.getptr(!p_shadow_pass && p_material->shader->spatial.uses_world_coordinates ? default_worldcoord_material_twosided : default_material_twosided);
+				no_cull = true;
+				mirror = false;
+			} else {
+				p_material = storage->material_owner.getptr(!p_shadow_pass && p_material->shader->spatial.uses_world_coordinates ? default_worldcoord_material : default_material);
+			}
+		}
+
+		has_alpha = false;
+	}
 
 	RenderList::Element *e = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
 
@@ -724,46 +759,107 @@ void RasterizerSceneGLES2::_add_geometry_with_material(RasterizerStorageGLES2::G
 	e->instance = p_instance;
 	e->owner = p_owner;
 	e->sort_key = 0;
+	e->depth_key = 0;
+	e->use_accum = false;
+	e->light_index = RenderList::MAX_LIGHTS;
+	e->use_accum_ptr = &e->use_accum;
+
+	if (e->geometry->last_pass != render_pass) {
+		e->geometry->last_pass = render_pass;
+		e->geometry->index = current_geometry_index++;
+	}
 
-	// TODO check render pass of geometry
-
-	// TODO check directional light flag
+	e->geometry_index = e->geometry->index;
 
-	if (p_depth_pass) {
-		// if we are in the depth pass we can sort out a few things to improve performance
+	if (e->material->last_pass != render_pass) {
+		e->material->last_pass = render_pass;
+		e->material->index = current_material_index++;
 
-		if (has_blend_alpha || p_material->shader->spatial.uses_depth_texture || (has_base_alpha && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES2::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS)) {
-			return;
+		if (e->material->shader->last_pass != render_pass) {
+			e->material->shader->index = current_shader_index++;
 		}
+	}
 
-		if (p_material->shader->spatial.uses_alpha_scissor && !p_material->shader->spatial.writes_modelview_or_projection && !p_material->shader->spatial.uses_vertex && !p_material->shader->spatial.uses_discard && p_material->shader->spatial.depth_draw_mode != RasterizerStorageGLES2::Shader::Spatial::DEPTH_DRAW_ALPHA_PREPASS) {
+	e->material_index = e->material->index;
 
-			// shader doesn't use discard or writes a custom vertex position,
-			// so we can use a stripped down shader instead
+	e->refprobe_0_index = 0xFF; //refprobe disabled by default
+	e->refprobe_1_index = 0xFF; //refprobe disabled by default
 
-			// TODO twosided and worldcoord stuff
+	if (!p_depth_pass) {
 
-			p_material = storage->material_owner.getptr(default_material_twosided);
-		}
+		e->depth_layer = e->instance->depth_layer;
+		e->priority = p_material->render_priority;
 
-		has_alpha = false;
-	}
+		//if (e->instance->reflection_probe_instances.size() > 0 ) {
+		//	RasterizerStorageGLES2::
+		//}
 
-	e->sort_key |= uint64_t(e->geometry->index) << RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
-	e->sort_key |= uint64_t(e->instance->base_type) << RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
+		//add directional lights
 
-	if (p_material->shader->spatial.unshaded) {
-		e->sort_key |= SORT_KEY_UNSHADED_FLAG;
-	}
+		if (p_material->shader->spatial.unshaded) {
+			e->light_mode = LIGHTMODE_UNSHADED;
+		} else {
 
-	if (!p_depth_pass) {
-		e->sort_key |= uint64_t(e->material->index) << RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
+			bool copy = false;
 
-		e->sort_key |= uint64_t(p_material->render_priority + 128) << RenderList::SORT_KEY_PRIORITY_SHIFT;
-	} else {
-		// TODO
+			for (int i = 0; i < render_directional_lights; i++) {
+
+				if (copy) {
+					RenderList::Element *e2 = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
+					if (!e2) {
+						break;
+					}
+					*e2 = *e; //this includes accum ptr :)
+					e = e2;
+				}
+
+				//directional sort key
+				e->light_type1 = 0;
+				e->light_type2 = 1;
+				e->light_index = i;
+
+				copy = true;
+			}
+
+			//add omni / spots
+
+			for (int i = 0; i < e->instance->light_instances.size(); i++) {
+
+				LightInstance *li = light_instance_owner.getornull(e->instance->light_instances[i]);
+
+				if (li->light_index >= render_light_instance_count) {
+					continue; // too many
+				}
+
+				if (copy) {
+					RenderList::Element *e2 = has_alpha ? render_list.add_alpha_element() : render_list.add_element();
+					if (!e2) {
+						break;
+					}
+					*e2 = *e; //this includes accum ptr :)
+					e = e2;
+				}
+
+				//directional sort key
+				e->light_type1 = 1;
+				e->light_type2 = li->light_ptr->type == VisualServer::LIGHT_OMNI ? 0 : 1;
+				e->light_index = li->light_index;
+
+				copy = true;
+			}
+
+			if (e->instance->lightmap.is_valid()) {
+				e->light_mode = LIGHTMODE_LIGHTMAP;
+			} else if (!e->instance->lightmap_capture_data.empty()) {
+				e->light_mode = LIGHTMODE_LIGHTMAP_CAPTURE;
+			} else {
+				e->light_mode = LIGHTMODE_NORMAL;
+			}
+		}
 	}
 
+	// do not add anything here, as lights are duplicated elements..
+
 	if (p_material->shader->spatial.uses_time) {
 		VisualServerRaster::redraw_request();
 	}
@@ -771,6 +867,13 @@ void RasterizerSceneGLES2::_add_geometry_with_material(RasterizerStorageGLES2::G
 
 void RasterizerSceneGLES2::_fill_render_list(InstanceBase **p_cull_result, int p_cull_count, bool p_depth_pass, bool p_shadow_pass) {
 
+	render_pass++;
+	current_material_index = 0;
+	current_geometry_index = 0;
+	current_light_index = 0;
+	current_refprobe_index = 0;
+	current_shader_index = 0;
+
 	for (int i = 0; i < p_cull_count; i++) {
 
 		InstanceBase *instance = p_cull_result[i];
@@ -838,13 +941,13 @@ static const GLenum gl_primitive[] = {
 	GL_TRIANGLE_FAN
 };
 
-void RasterizerSceneGLES2::_setup_material(RasterizerStorageGLES2::Material *p_material, bool p_reverse_cull, bool p_alpha_pass, Size2i p_skeleton_tex_size) {
+bool RasterizerSceneGLES2::_setup_material(RasterizerStorageGLES2::Material *p_material, bool p_reverse_cull, bool p_alpha_pass, Size2i p_skeleton_tex_size) {
 
 	// material parameters
 
 	state.scene_shader.set_custom_shader(p_material->shader->custom_code_id);
 
-	state.scene_shader.bind();
+	bool shader_rebind = state.scene_shader.bind();
 
 	if (p_material->shader->spatial.no_depth_test) {
 		glDisable(GL_DEPTH_TEST);
@@ -923,193 +1026,169 @@ void RasterizerSceneGLES2::_setup_material(RasterizerStorageGLES2::Material *p_m
 		glBindTexture(t->target, t->tex_id);
 	}
 	state.scene_shader.use_material((void *)p_material);
+
+	return shader_rebind;
 }
 
 void RasterizerSceneGLES2::_setup_geometry(RenderList::Element *p_element, RasterizerStorageGLES2::Skeleton *p_skeleton) {
 
-	state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, p_skeleton != NULL);
-	state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON_SOFTWARE, !storage->config.float_texture_supported);
-	// state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON_SOFTWARE, true);
-
 	switch (p_element->instance->base_type) {
 
 		case VS::INSTANCE_MESH: {
 			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
 
-			state.scene_shader.set_conditional(SceneShaderGLES2::USE_INSTANCING, false);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_COLOR_INTERP, s->attribs[VS::ARRAY_COLOR].enabled);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV_INTERP, s->attribs[VS::ARRAY_TEX_UV].enabled);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV2_INTERP, s->attribs[VS::ARRAY_TEX_UV2].enabled);
-
-		} break;
-
-		case VS::INSTANCE_MULTIMESH: {
-			RasterizerStorageGLES2::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES2::MultiMesh *>(p_element->owner);
-			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
-
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_COLOR_INTERP, true);
-			state.scene_shader.set_conditional(SceneShaderGLES2::USE_INSTANCING, true);
-
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV_INTERP, s->attribs[VS::ARRAY_TEX_UV].enabled);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV2_INTERP, s->attribs[VS::ARRAY_TEX_UV2].enabled);
-		} break;
-
-		case VS::INSTANCE_IMMEDIATE: {
-			state.scene_shader.set_conditional(SceneShaderGLES2::USE_INSTANCING, false);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_COLOR_INTERP, true);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV_INTERP, true);
-			state.scene_shader.set_conditional(SceneShaderGLES2::ENABLE_UV2_INTERP, true);
-		} break;
-
-		default: {
-
-		} break;
-	}
-
-	if (storage->config.float_texture_supported) {
-		if (p_skeleton) {
-			glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 1);
-			glBindTexture(GL_TEXTURE_2D, p_skeleton->tex_id);
-		}
-
-		return;
-	}
-
-	if (p_skeleton) {
-		ERR_FAIL_COND(p_skeleton->use_2d);
-
-		PoolVector<float> &transform_buffer = storage->resources.skeleton_transform_cpu_buffer;
-
-		switch (p_element->instance->base_type) {
-			case VS::INSTANCE_MESH: {
-				RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
+			glBindBuffer(GL_ARRAY_BUFFER, s->vertex_id);
 
-				if (!s->attribs[VS::ARRAY_BONES].enabled || !s->attribs[VS::ARRAY_WEIGHTS].enabled) {
-					break; // the whole instance has a skeleton, but this surface is not affected by it.
-				}
+			if (s->index_array_len > 0) {
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->index_id);
+			}
 
-				// 3 * vec4 per vertex
-				if (transform_buffer.size() < s->array_len * 12) {
-					transform_buffer.resize(s->array_len * 12);
+			for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
+				if (s->attribs[i].enabled) {
+					glEnableVertexAttribArray(i);
+					glVertexAttribPointer(s->attribs[i].index, s->attribs[i].size, s->attribs[i].type, s->attribs[i].normalized, s->attribs[i].stride, (uint8_t *)0 + s->attribs[i].offset);
+				} else {
+					glDisableVertexAttribArray(i);
+					switch (i) {
+						case VS::ARRAY_NORMAL: {
+							glVertexAttrib4f(VS::ARRAY_COLOR, 0.0, 0.0, 1, 1);
+						} break;
+						case VS::ARRAY_COLOR: {
+							glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
+
+						} break;
+						default: {}
+					}
 				}
+			}
 
-				const size_t bones_offset = s->attribs[VS::ARRAY_BONES].offset;
-				const size_t bones_stride = s->attribs[VS::ARRAY_BONES].stride;
-				const size_t bone_weight_offset = s->attribs[VS::ARRAY_WEIGHTS].offset;
-				const size_t bone_weight_stride = s->attribs[VS::ARRAY_WEIGHTS].stride;
+			bool clear_skeleton_buffer = !storage->config.float_texture_supported;
 
-				{
-					PoolVector<float>::Write write = transform_buffer.write();
-					float *buffer = write.ptr();
+			if (p_skeleton) {
 
-					PoolVector<uint8_t>::Read vertex_array_read = s->data.read();
-					const uint8_t *vertex_data = vertex_array_read.ptr();
+				if (storage->config.float_texture_supported) {
+					//use float texture workflow
+					glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 1);
+					glBindTexture(GL_TEXTURE_2D, p_skeleton->tex_id);
+				} else {
+					//use transform buffer workflow
+					ERR_FAIL_COND(p_skeleton->use_2d);
 
-					for (int i = 0; i < s->array_len; i++) {
+					PoolVector<float> &transform_buffer = storage->resources.skeleton_transform_cpu_buffer;
 
-						// do magic
+					if (!s->attribs[VS::ARRAY_BONES].enabled || !s->attribs[VS::ARRAY_WEIGHTS].enabled) {
+						break; // the whole instance has a skeleton, but this surface is not affected by it.
+					}
 
-						size_t bones[4];
-						float bone_weight[4];
+					// 3 * vec4 per vertex
+					if (transform_buffer.size() < s->array_len * 12) {
+						transform_buffer.resize(s->array_len * 12);
+					}
 
-						if (s->attribs[VS::ARRAY_BONES].type == GL_UNSIGNED_BYTE) {
-							// read as byte
-							const uint8_t *bones_ptr = vertex_data + bones_offset + (i * bones_stride);
-							bones[0] = bones_ptr[0];
-							bones[1] = bones_ptr[1];
-							bones[2] = bones_ptr[2];
-							bones[3] = bones_ptr[3];
-						} else {
-							// read as short
-							const uint16_t *bones_ptr = (const uint16_t *)(vertex_data + bones_offset + (i * bones_stride));
-							bones[0] = bones_ptr[0];
-							bones[1] = bones_ptr[1];
-							bones[2] = bones_ptr[2];
-							bones[3] = bones_ptr[3];
+					const size_t bones_offset = s->attribs[VS::ARRAY_BONES].offset;
+					const size_t bones_stride = s->attribs[VS::ARRAY_BONES].stride;
+					const size_t bone_weight_offset = s->attribs[VS::ARRAY_WEIGHTS].offset;
+					const size_t bone_weight_stride = s->attribs[VS::ARRAY_WEIGHTS].stride;
+
+					{
+						PoolVector<float>::Write write = transform_buffer.write();
+						float *buffer = write.ptr();
+
+						PoolVector<uint8_t>::Read vertex_array_read = s->data.read();
+						const uint8_t *vertex_data = vertex_array_read.ptr();
+
+						for (int i = 0; i < s->array_len; i++) {
+
+							// do magic
+
+							size_t bones[4];
+							float bone_weight[4];
+
+							if (s->attribs[VS::ARRAY_BONES].type == GL_UNSIGNED_BYTE) {
+								// read as byte
+								const uint8_t *bones_ptr = vertex_data + bones_offset + (i * bones_stride);
+								bones[0] = bones_ptr[0];
+								bones[1] = bones_ptr[1];
+								bones[2] = bones_ptr[2];
+								bones[3] = bones_ptr[3];
+							} else {
+								// read as short
+								const uint16_t *bones_ptr = (const uint16_t *)(vertex_data + bones_offset + (i * bones_stride));
+								bones[0] = bones_ptr[0];
+								bones[1] = bones_ptr[1];
+								bones[2] = bones_ptr[2];
+								bones[3] = bones_ptr[3];
+							}
+
+							if (s->attribs[VS::ARRAY_WEIGHTS].type == GL_FLOAT) {
+								// read as float
+								const float *weight_ptr = (const float *)(vertex_data + bone_weight_offset + (i * bone_weight_stride));
+								bone_weight[0] = weight_ptr[0];
+								bone_weight[1] = weight_ptr[1];
+								bone_weight[2] = weight_ptr[2];
+								bone_weight[3] = weight_ptr[3];
+							} else {
+								// read as half
+								const uint16_t *weight_ptr = (const uint16_t *)(vertex_data + bone_weight_offset + (i * bone_weight_stride));
+								bone_weight[0] = (weight_ptr[0] / (float)0xFFFF);
+								bone_weight[1] = (weight_ptr[1] / (float)0xFFFF);
+								bone_weight[2] = (weight_ptr[2] / (float)0xFFFF);
+								bone_weight[3] = (weight_ptr[3] / (float)0xFFFF);
+							}
+
+							size_t offset = i * 12;
+
+							Transform transform;
+
+							Transform bone_transforms[4] = {
+								storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[0]),
+								storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[1]),
+								storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[2]),
+								storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[3]),
+							};
+
+							transform.origin =
+									bone_weight[0] * bone_transforms[0].origin +
+									bone_weight[1] * bone_transforms[1].origin +
+									bone_weight[2] * bone_transforms[2].origin +
+									bone_weight[3] * bone_transforms[3].origin;
+
+							transform.basis =
+									bone_transforms[0].basis * bone_weight[0] +
+									bone_transforms[1].basis * bone_weight[1] +
+									bone_transforms[2].basis * bone_weight[2] +
+									bone_transforms[3].basis * bone_weight[3];
+
+							float row[3][4] = {
+								{ transform.basis[0][0], transform.basis[0][1], transform.basis[0][2], transform.origin[0] },
+								{ transform.basis[1][0], transform.basis[1][1], transform.basis[1][2], transform.origin[1] },
+								{ transform.basis[2][0], transform.basis[2][1], transform.basis[2][2], transform.origin[2] },
+							};
+
+							size_t transform_buffer_offset = i * 12;
+
+							copymem(&buffer[transform_buffer_offset], row, sizeof(row));
 						}
-
-						if (s->attribs[VS::ARRAY_WEIGHTS].type == GL_FLOAT) {
-							// read as float
-							const float *weight_ptr = (const float *)(vertex_data + bone_weight_offset + (i * bone_weight_stride));
-							bone_weight[0] = weight_ptr[0];
-							bone_weight[1] = weight_ptr[1];
-							bone_weight[2] = weight_ptr[2];
-							bone_weight[3] = weight_ptr[3];
-						} else {
-							// read as half
-							const uint16_t *weight_ptr = (const uint16_t *)(vertex_data + bone_weight_offset + (i * bone_weight_stride));
-							bone_weight[0] = (weight_ptr[0] / (float)0xFFFF);
-							bone_weight[1] = (weight_ptr[1] / (float)0xFFFF);
-							bone_weight[2] = (weight_ptr[2] / (float)0xFFFF);
-							bone_weight[3] = (weight_ptr[3] / (float)0xFFFF);
-						}
-
-						size_t offset = i * 12;
-
-						Transform transform;
-
-						Transform bone_transforms[4] = {
-							storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[0]),
-							storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[1]),
-							storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[2]),
-							storage->skeleton_bone_get_transform(p_element->instance->skeleton, bones[3]),
-						};
-
-						transform.origin =
-								bone_weight[0] * bone_transforms[0].origin +
-								bone_weight[1] * bone_transforms[1].origin +
-								bone_weight[2] * bone_transforms[2].origin +
-								bone_weight[3] * bone_transforms[3].origin;
-
-						transform.basis =
-								bone_transforms[0].basis * bone_weight[0] +
-								bone_transforms[1].basis * bone_weight[1] +
-								bone_transforms[2].basis * bone_weight[2] +
-								bone_transforms[3].basis * bone_weight[3];
-
-						float row[3][4] = {
-							{ transform.basis[0][0], transform.basis[0][1], transform.basis[0][2], transform.origin[0] },
-							{ transform.basis[1][0], transform.basis[1][1], transform.basis[1][2], transform.origin[1] },
-							{ transform.basis[2][0], transform.basis[2][1], transform.basis[2][2], transform.origin[2] },
-						};
-
-						size_t transform_buffer_offset = i * 12;
-
-						copymem(&buffer[transform_buffer_offset], row, sizeof(row));
 					}
-				}
 
-				storage->_update_skeleton_transform_buffer(transform_buffer, s->array_len * 12);
-			} break;
+					storage->_update_skeleton_transform_buffer(transform_buffer, s->array_len * 12);
 
-			default: {
+					//enable transform buffer and bind it
+					glBindBuffer(GL_ARRAY_BUFFER, storage->resources.skeleton_transform_buffer);
 
-			} break;
-		}
-	}
-}
+					glEnableVertexAttribArray(VS::ARRAY_MAX + 0);
+					glEnableVertexAttribArray(VS::ARRAY_MAX + 1);
+					glEnableVertexAttribArray(VS::ARRAY_MAX + 2);
 
-void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
+					glVertexAttribPointer(VS::ARRAY_MAX + 0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 0));
+					glVertexAttribPointer(VS::ARRAY_MAX + 1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 1));
+					glVertexAttribPointer(VS::ARRAY_MAX + 2, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 2));
 
-	switch (p_element->instance->base_type) {
-
-		case VS::INSTANCE_MESH: {
-
-			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
-
-			// set up
-
-			if (p_element->instance->skeleton.is_valid() && s->attribs[VS::ARRAY_BONES].enabled && s->attribs[VS::ARRAY_WEIGHTS].enabled) {
-				glBindBuffer(GL_ARRAY_BUFFER, storage->resources.skeleton_transform_buffer);
-
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 0);
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 1);
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 2);
+					clear_skeleton_buffer = false;
+				}
+			}
 
-				glVertexAttribPointer(VS::ARRAY_MAX + 0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 0));
-				glVertexAttribPointer(VS::ARRAY_MAX + 1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 1));
-				glVertexAttribPointer(VS::ARRAY_MAX + 2, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 2));
-			} else {
+			if (clear_skeleton_buffer) {
 				// just to make sure
 				glDisableVertexAttribArray(VS::ARRAY_MAX + 0);
 				glDisableVertexAttribArray(VS::ARRAY_MAX + 1);
@@ -1120,6 +1199,12 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 				glVertexAttrib4f(VS::ARRAY_MAX + 2, 0, 0, 1, 0);
 			}
 
+		} break;
+
+		case VS::INSTANCE_MULTIMESH: {
+			RasterizerStorageGLES2::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES2::MultiMesh *>(p_element->owner);
+			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
+
 			glBindBuffer(GL_ARRAY_BUFFER, s->vertex_id);
 
 			if (s->index_array_len > 0) {
@@ -1132,61 +1217,61 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 					glVertexAttribPointer(s->attribs[i].index, s->attribs[i].size, s->attribs[i].type, s->attribs[i].normalized, s->attribs[i].stride, (uint8_t *)0 + s->attribs[i].offset);
 				} else {
 					glDisableVertexAttribArray(i);
+					switch (i) {
+						case VS::ARRAY_NORMAL: {
+							glVertexAttrib4f(VS::ARRAY_COLOR, 0.0, 0.0, 1, 1);
+						} break;
+						case VS::ARRAY_COLOR: {
+							glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
+
+						} break;
+						default: {}
+					}
 				}
 			}
 
-			// drawing
+			if (!storage->config.float_texture_supported) {
+				// just to make sure, clear skeleton buffer too
+				glDisableVertexAttribArray(VS::ARRAY_MAX + 0);
+				glDisableVertexAttribArray(VS::ARRAY_MAX + 1);
+				glDisableVertexAttribArray(VS::ARRAY_MAX + 2);
 
-			if (s->index_array_len > 0) {
-				glDrawElements(gl_primitive[s->primitive], s->index_array_len, (s->array_len >= (1 << 16)) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
-			} else {
-				glDrawArrays(gl_primitive[s->primitive], 0, s->array_len);
+				glVertexAttrib4f(VS::ARRAY_MAX + 0, 1, 0, 0, 0);
+				glVertexAttrib4f(VS::ARRAY_MAX + 1, 0, 1, 0, 0);
+				glVertexAttrib4f(VS::ARRAY_MAX + 2, 0, 0, 1, 0);
 			}
 
-			// tear down
-
-			for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
-				glDisableVertexAttribArray(i);
-			}
+		} break;
 
-			if (s->index_array_len > 0) {
-				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-			}
+		case VS::INSTANCE_IMMEDIATE: {
+		} break;
 
-			if (p_element->instance->skeleton.is_valid() && s->attribs[VS::ARRAY_BONES].enabled && s->attribs[VS::ARRAY_WEIGHTS].enabled) {
-				glBindBuffer(GL_ARRAY_BUFFER, storage->resources.skeleton_transform_buffer);
+		default: {
 
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 0);
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 1);
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 2);
-			}
+		} break;
+	}
+}
 
-			glBindBuffer(GL_ARRAY_BUFFER, 0);
+void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 
-		} break;
+	switch (p_element->instance->base_type) {
 
-		case VS::INSTANCE_MULTIMESH: {
+		case VS::INSTANCE_MESH: {
 
-			RasterizerStorageGLES2::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES2::MultiMesh *>(p_element->owner);
 			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
 
-			int amount = MIN(multi_mesh->size, multi_mesh->visible_instances);
-			if (amount == -1) {
-				amount = multi_mesh->size;
+			// drawing
+
+			if (s->index_array_len > 0) {
+				glDrawElements(gl_primitive[s->primitive], s->index_array_len, (s->array_len >= (1 << 16)) ? GL_UNSIGNED_INT : GL_UNSIGNED_SHORT, 0);
+			} else {
+				glDrawArrays(gl_primitive[s->primitive], 0, s->array_len);
 			}
 
 			if (p_element->instance->skeleton.is_valid() && s->attribs[VS::ARRAY_BONES].enabled && s->attribs[VS::ARRAY_WEIGHTS].enabled) {
+				//clean up after skeleton
 				glBindBuffer(GL_ARRAY_BUFFER, storage->resources.skeleton_transform_buffer);
 
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 0);
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 1);
-				glEnableVertexAttribArray(VS::ARRAY_MAX + 2);
-
-				glVertexAttribPointer(VS::ARRAY_MAX + 0, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 0));
-				glVertexAttribPointer(VS::ARRAY_MAX + 1, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 1));
-				glVertexAttribPointer(VS::ARRAY_MAX + 2, 4, GL_FLOAT, GL_FALSE, sizeof(float) * 12, (const void *)(sizeof(float) * 4 * 2));
-			} else {
-				// just to make sure
 				glDisableVertexAttribArray(VS::ARRAY_MAX + 0);
 				glDisableVertexAttribArray(VS::ARRAY_MAX + 1);
 				glDisableVertexAttribArray(VS::ARRAY_MAX + 2);
@@ -1196,36 +1281,19 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 				glVertexAttrib4f(VS::ARRAY_MAX + 2, 0, 0, 1, 0);
 			}
 
-			glBindBuffer(GL_ARRAY_BUFFER, s->vertex_id);
-
-			if (s->index_array_len > 0) {
-				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s->index_id);
-			}
+		} break;
 
-			for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
-				if (s->attribs[i].enabled) {
-					glEnableVertexAttribArray(i);
-					glVertexAttribPointer(s->attribs[i].index, s->attribs[i].size, s->attribs[i].type, s->attribs[i].normalized, s->attribs[i].stride, (uint8_t *)0 + s->attribs[i].offset);
-				} else {
-					glDisableVertexAttribArray(i);
-				}
-			}
+		case VS::INSTANCE_MULTIMESH: {
 
-			glDisableVertexAttribArray(12); // transform 0
-			glDisableVertexAttribArray(13); // transform 1
-			glDisableVertexAttribArray(14); // transform 2
-			glDisableVertexAttribArray(15); // color
-			glDisableVertexAttribArray(8); // custom data
+			RasterizerStorageGLES2::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES2::MultiMesh *>(p_element->owner);
+			RasterizerStorageGLES2::Surface *s = static_cast<RasterizerStorageGLES2::Surface *>(p_element->geometry);
 
-			if (!s->attribs[VS::ARRAY_COLOR].enabled) {
-				glDisableVertexAttribArray(VS::ARRAY_COLOR);
+			int amount = MIN(multi_mesh->size, multi_mesh->visible_instances);
 
-				glVertexAttrib4f(VS::ARRAY_COLOR, 1, 1, 1, 1);
+			if (amount == -1) {
+				amount = multi_mesh->size;
 			}
 
-			glVertexAttrib4f(15, 1, 1, 1, 1);
-			glVertexAttrib4f(8, 0, 0, 0, 0);
-
 			int stride = multi_mesh->color_floats + multi_mesh->custom_data_floats + multi_mesh->xform_floats;
 
 			int color_ofs = multi_mesh->xform_floats;
@@ -1260,22 +1328,27 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 						{ transform.basis[2][0], transform.basis[2][1], transform.basis[2][2], transform.origin[2] },
 					};
 
-					glVertexAttrib4fv(12, row[0]);
-					glVertexAttrib4fv(13, row[1]);
-					glVertexAttrib4fv(14, row[2]);
+					glVertexAttrib4fv(VS::ARRAY_MAX + 0, row[0]);
+					glVertexAttrib4fv(VS::ARRAY_MAX + 1, row[1]);
+					glVertexAttrib4fv(VS::ARRAY_MAX + 2, row[2]);
 				}
 
 				if (multi_mesh->color_floats) {
 					if (multi_mesh->color_format == VS::MULTIMESH_COLOR_8BIT) {
 						uint8_t *color_data = (uint8_t *)(buffer + color_ofs);
-						glVertexAttrib4f(15, color_data[0] / 255.0, color_data[1] / 255.0, color_data[2] / 255.0, color_data[3] / 255.0);
+						glVertexAttrib4f(VS::ARRAY_MAX + 3, color_data[0] / 255.0, color_data[1] / 255.0, color_data[2] / 255.0, color_data[3] / 255.0);
 					} else {
-						glVertexAttrib4fv(15, buffer + color_ofs);
+						glVertexAttrib4fv(VS::ARRAY_MAX + 3, buffer + color_ofs);
 					}
 				}
 
 				if (multi_mesh->custom_data_floats) {
-					glVertexAttrib4fv(8, buffer + custom_data_ofs);
+					if (multi_mesh->custom_data_format == VS::MULTIMESH_CUSTOM_DATA_8BIT) {
+						uint8_t *custom_data = (uint8_t *)(buffer + custom_data_ofs);
+						glVertexAttrib4f(VS::ARRAY_MAX + 4, custom_data[0] / 255.0, custom_data[1] / 255.0, custom_data[2] / 255.0, custom_data[3] / 255.0);
+					} else {
+						glVertexAttrib4fv(VS::ARRAY_MAX + 4, buffer + custom_data_ofs);
+					}
 				}
 
 				if (s->index_array_len > 0) {
@@ -1285,25 +1358,6 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 				}
 			}
 
-			// tear down
-
-			for (int i = 0; i < VS::ARRAY_MAX - 1; i++) {
-				glDisableVertexAttribArray(i);
-			}
-
-			if (s->index_array_len > 0) {
-				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
-			}
-
-			if (p_element->instance->skeleton.is_valid() && s->attribs[VS::ARRAY_BONES].enabled && s->attribs[VS::ARRAY_WEIGHTS].enabled) {
-				glBindBuffer(GL_ARRAY_BUFFER, storage->resources.skeleton_transform_buffer);
-
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 0);
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 1);
-				glDisableVertexAttribArray(VS::ARRAY_MAX + 2);
-			}
-
-			glBindBuffer(GL_ARRAY_BUFFER, 0);
 		} break;
 
 		case VS::INSTANCE_IMMEDIATE: {
@@ -1420,505 +1474,549 @@ void RasterizerSceneGLES2::_render_geometry(RenderList::Element *p_element) {
 	}
 }
 
-void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, int p_element_count, const RID *p_directional_lights, int p_directional_light_count, const Transform &p_view_transform, const CameraMatrix &p_projection, RID p_shadow_atlas, Environment *p_env, GLuint p_base_env, float p_shadow_bias, float p_shadow_normal_bias, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow, bool p_directional_add) {
-
-	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
-
-	Vector2 screen_pixel_size;
-	screen_pixel_size.x = 1.0 / storage->frame.current_rt->width;
-	screen_pixel_size.y = 1.0 / storage->frame.current_rt->height;
-
-	bool use_radiance_map = false;
-
-	VMap<RID, Vector<RenderList::Element *> > lit_objects;
-
-	for (int i = 0; i < p_element_count; i++) {
-		RenderList::Element *e = p_elements[i];
+void RasterizerSceneGLES2::_setup_light_type(LightInstance *p_light, ShadowAtlas *shadow_atlas) {
 
-		RasterizerStorageGLES2::Material *material = e->material;
-
-		RasterizerStorageGLES2::Skeleton *skeleton = storage->skeleton_owner.getornull(e->instance->skeleton);
-
-		if (p_base_env) {
-			glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 2);
-			glBindTexture(GL_TEXTURE_CUBE_MAP, p_base_env);
-			use_radiance_map = true;
-		}
-		state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, use_radiance_map);
-
-		if (material->shader->spatial.unshaded) {
-			state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, false);
-		} else {
-			state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, use_radiance_map);
-		}
-
-		// opaque pass
-
-		state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_PASS, false);
-
-		_setup_geometry(e, skeleton);
-
-		_setup_material(material, p_reverse_cull, p_alpha_pass, Size2i(skeleton ? skeleton->size * 3 : 0, 0));
+	//turn off all by default
+	state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTING, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::USE_SHADOW, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_5, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_13, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_DIRECTIONAL, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_OMNI, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_SPOT, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM2, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM4, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::USE_SHADOW, false);
 
-		if (use_radiance_map) {
-			state.scene_shader.set_uniform(SceneShaderGLES2::RADIANCE_INVERSE_XFORM, p_view_transform);
-		}
+	if (!p_light) { //no light, return off
+		return;
+	}
 
-		if (p_shadow) {
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_BIAS, p_shadow_bias);
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_NORMAL_BIAS, p_shadow_normal_bias);
-		}
+	//turn on lighting
+	state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTING, true);
 
-		if (p_env) {
-			state.scene_shader.set_uniform(SceneShaderGLES2::BG_ENERGY, p_env->bg_energy);
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_SKY_CONTRIBUTION, p_env->ambient_sky_contribution);
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_COLOR, p_env->ambient_color);
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_ENERGY, p_env->ambient_energy);
+	switch (p_light->light_ptr->type) {
+		case VS::LIGHT_DIRECTIONAL: {
 
-		} else {
-			state.scene_shader.set_uniform(SceneShaderGLES2::BG_ENERGY, 1.0);
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_SKY_CONTRIBUTION, 1.0);
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_COLOR, Color(1.0, 1.0, 1.0, 1.0));
-			state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_ENERGY, 1.0);
-		}
+			state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_DIRECTIONAL, true);
+			switch (p_light->light_ptr->directional_shadow_mode) {
+				case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
+					//no need
+				} break;
+				case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
+					state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM2, true);
 
-		glEnable(GL_BLEND);
+				} break;
+				case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
+					state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM4, true);
+				} break;
+			}
 
-		if (p_alpha_pass || p_directional_add) {
-			int desired_blend_mode;
-			if (p_directional_add) {
-				desired_blend_mode = RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_ADD;
-			} else {
-				desired_blend_mode = material->shader->spatial.blend_mode;
+			state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, p_light->light_ptr->directional_blend_splits);
+			if (p_light->light_ptr->shadow) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SHADOW, true);
+				glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 3);
+				glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_5, shadow_filter_mode == SHADOW_FILTER_PCF5);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_13, shadow_filter_mode == SHADOW_FILTER_PCF13);
 			}
 
-			switch (desired_blend_mode) {
+		} break;
+		case VS::LIGHT_OMNI: {
+
+			state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_OMNI, true);
+			if (shadow_atlas && p_light->light_ptr->shadow) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SHADOW, true);
+				glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 3);
+				glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_5, shadow_filter_mode == SHADOW_FILTER_PCF5);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_13, shadow_filter_mode == SHADOW_FILTER_PCF13);
+			}
+		} break;
+		case VS::LIGHT_SPOT: {
+
+			state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_MODE_SPOT, true);
+			if (shadow_atlas && p_light->light_ptr->shadow) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SHADOW, true);
+				glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 3);
+				glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_5, shadow_filter_mode == SHADOW_FILTER_PCF5);
+				state.scene_shader.set_conditional(SceneShaderGLES2::SHADOW_MODE_PCF_13, shadow_filter_mode == SHADOW_FILTER_PCF13);
+			}
+		} break;
+	}
+}
 
-				case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_MIX: {
-					glBlendEquation(GL_FUNC_ADD);
-					if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
-						glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-					} else {
-						glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-					}
+void RasterizerSceneGLES2::_setup_light(LightInstance *light, ShadowAtlas *shadow_atlas, const Transform &p_view_transform) {
 
-				} break;
-				case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_ADD: {
+	RasterizerStorageGLES2::Light *light_ptr = light->light_ptr;
 
-					glBlendEquation(GL_FUNC_ADD);
-					glBlendFunc(p_alpha_pass ? GL_SRC_ALPHA : GL_ONE, GL_ONE);
+	//common parameters
+	float energy = light_ptr->param[VS::LIGHT_PARAM_ENERGY];
+	float specular = light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+	float sign = light_ptr->negative ? -1 : 1;
 
-				} break;
-				case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_SUB: {
+	state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPECULAR, specular);
+	Color color = light_ptr->color * sign * energy * M_PI;
+	state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_COLOR, color);
 
-					glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
-					glBlendFunc(GL_SRC_ALPHA, GL_ONE);
-				} break;
-				case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_MUL: {
-					glBlendEquation(GL_FUNC_ADD);
-					if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
-						glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_DST_ALPHA, GL_ZERO);
-					} else {
-						glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_ZERO, GL_ONE);
-					}
+	//specific parameters
 
-				} break;
-			}
-		} else {
-			// no blend mode given - assume mix
-			glBlendEquation(GL_FUNC_ADD);
-			if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
-				glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
-			} else {
-				glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
-			}
-		}
+	switch (light_ptr->type) {
+		case VS::LIGHT_DIRECTIONAL: {
+			//not using inverse for performance, view should be normalized anyway
+			Vector3 direction = p_view_transform.basis.xform_inv(light->transform.basis.xform(Vector3(0, 0, -1))).normalized();
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_DIRECTION, direction);
 
-		state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_MATRIX, p_view_transform.inverse());
-		state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_INVERSE_MATRIX, p_view_transform);
-		state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_MATRIX, p_projection);
-		state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_INVERSE_MATRIX, p_projection.inverse());
+			CameraMatrix matrices[4];
 
-		state.scene_shader.set_uniform(SceneShaderGLES2::TIME, storage->frame.time[0]);
+			if (light_ptr->shadow && directional_shadow.depth) {
 
-		state.scene_shader.set_uniform(SceneShaderGLES2::SCREEN_PIXEL_SIZE, screen_pixel_size);
-		state.scene_shader.set_uniform(SceneShaderGLES2::NORMAL_MULT, 1.0); // TODO mirror?
-		state.scene_shader.set_uniform(SceneShaderGLES2::WORLD_TRANSFORM, e->instance->transform);
+				int shadow_count = 0;
+				Color split_offsets;
 
-		_render_geometry(e);
+				switch (light_ptr->directional_shadow_mode) {
+					case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
+						shadow_count = 1;
+					} break;
 
-		if (material->shader->spatial.unshaded)
-			continue;
+					case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
+						shadow_count = 2;
+					} break;
 
-		if (p_shadow)
-			continue;
+					case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
+						shadow_count = 4;
+					} break;
+				}
 
-		for (int light = 0; light < e->instance->light_instances.size(); light++) {
+				for (int k = 0; k < shadow_count; k++) {
 
-			RID light_instance = e->instance->light_instances[light];
+					uint32_t x = light->directional_rect.position.x;
+					uint32_t y = light->directional_rect.position.y;
+					uint32_t width = light->directional_rect.size.x;
+					uint32_t height = light->directional_rect.size.y;
 
-			lit_objects[light_instance].push_back(e);
-		}
-	}
+					if (light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
 
-	if (p_shadow) {
-		state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, false);
-		state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM4, false);
-		state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM2, false);
-		state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, false);
-		return;
-	}
+						width /= 2;
+						height /= 2;
 
-	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_PASS, true);
+						if (k == 0) {
 
-	glEnable(GL_BLEND);
-	glBlendEquation(GL_FUNC_ADD);
-	glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+						} else if (k == 1) {
+							x += width;
+						} else if (k == 2) {
+							y += height;
+						} else if (k == 3) {
+							x += width;
+							y += height;
+						}
 
-	for (int lo = 0; lo < lit_objects.size(); lo++) {
+					} else if (light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
 
-		RID key = lit_objects.getk(lo);
+						height /= 2;
 
-		LightInstance *light = light_instance_owner.getornull(key);
-		RasterizerStorageGLES2::Light *light_ptr = light->light_ptr;
+						if (k == 0) {
 
-		const Vector<RenderList::Element *> &list = lit_objects.getv(lo);
+						} else {
+							y += height;
+						}
+					}
 
-		for (int i = 0; i < list.size(); i++) {
+					split_offsets[k] = light->shadow_transform[k].split;
 
-			RenderList::Element *e = list[i];
-			RasterizerStorageGLES2::Material *material = e->material;
+					Transform modelview = (p_view_transform.inverse() * light->shadow_transform[k].transform).affine_inverse();
 
-			RasterizerStorageGLES2::Skeleton *skeleton = storage->skeleton_owner.getornull(e->instance->skeleton);
+					CameraMatrix bias;
+					bias.set_light_bias();
+					CameraMatrix rectm;
+					Rect2 atlas_rect = Rect2(float(x) / directional_shadow.size, float(y) / directional_shadow.size, float(width) / directional_shadow.size, float(height) / directional_shadow.size);
+					rectm.set_light_atlas_rect(atlas_rect);
 
-			{
-				_setup_geometry(e, skeleton);
+					CameraMatrix shadow_mtx = rectm * bias * light->shadow_transform[k].camera * modelview;
+					matrices[k] = shadow_mtx;
 
-				_setup_material(material, p_reverse_cull, p_alpha_pass, Size2i(skeleton ? skeleton->size * 3 : 0, 0));
-				if (shadow_atlas != NULL) {
-					glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 4);
-					glBindTexture(GL_TEXTURE_2D, shadow_atlas->depth);
+					/*Color light_clamp;
+					light_clamp[0] = atlas_rect.position.x;
+					light_clamp[1] = atlas_rect.position.y;
+					light_clamp[2] = atlas_rect.size.x;
+					light_clamp[3] = atlas_rect.size.y;*/
 				}
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_MATRIX, p_view_transform.inverse());
-				state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_INVERSE_MATRIX, p_view_transform);
-				state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_MATRIX, p_projection);
-				state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_INVERSE_MATRIX, p_projection.inverse());
+				//	state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
+				state.scene_shader.set_uniform(SceneShaderGLES2::SHADOW_PIXEL_SIZE, Size2(1.0 / directional_shadow.size, 1.0 / directional_shadow.size));
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPLIT_OFFSETS, split_offsets);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX, matrices[0]);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX2, matrices[1]);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX3, matrices[2]);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX4, matrices[3]);
+			}
+		} break;
+		case VS::LIGHT_OMNI: {
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::TIME, storage->frame.time[0]);
+			Vector3 position = p_view_transform.xform_inv(light->transform.origin);
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::SCREEN_PIXEL_SIZE, screen_pixel_size);
-				state.scene_shader.set_uniform(SceneShaderGLES2::NORMAL_MULT, 1.0); // TODO mirror?
-				state.scene_shader.set_uniform(SceneShaderGLES2::WORLD_TRANSFORM, e->instance->transform);
-			}
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_POSITION, position);
 
-			switch (light_ptr->type) {
-				case VS::LIGHT_OMNI: {
+			float range = light_ptr->param[VS::LIGHT_PARAM_RANGE];
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_RANGE, range);
 
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_TYPE, (int)1);
+			Color attenuation = Color(0.0, 0.0, 0.0, 0.0);
+			attenuation.a = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ATTENUATION, attenuation);
 
-					Vector3 position = p_view_transform.inverse().xform(light->transform.origin);
+			if (light_ptr->shadow && shadow_atlas->shadow_owners.has(light->self)) {
 
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_POSITION, position);
+				uint32_t key = shadow_atlas->shadow_owners[light->self];
 
-					float range = light_ptr->param[VS::LIGHT_PARAM_RANGE];
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_RANGE, range);
+				uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x03;
+				uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
 
-					Color attenuation = Color(0.0, 0.0, 0.0, 0.0);
-					attenuation.a = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ATTENUATION, attenuation);
+				ERR_BREAK(shadow >= (uint32_t)shadow_atlas->quadrants[quadrant].shadows.size());
 
-					if (light_ptr->shadow && shadow_atlas->shadow_owners.has(light->self)) {
+				uint32_t atlas_size = shadow_atlas->size;
+				uint32_t quadrant_size = atlas_size >> 1;
 
-						uint32_t key = shadow_atlas->shadow_owners[light->self];
+				uint32_t x = (quadrant & 1) * quadrant_size;
+				uint32_t y = (quadrant >> 1) * quadrant_size;
 
-						uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x03;
-						uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
+				uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
+				x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+				y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
 
-						ERR_CONTINUE(shadow >= (uint32_t)shadow_atlas->quadrants[quadrant].shadows.size());
+				uint32_t width = shadow_size;
+				uint32_t height = shadow_size;
 
-						uint32_t atlas_size = shadow_atlas->size;
-						uint32_t quadrant_size = atlas_size >> 1;
+				if (light->light_ptr->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+					height /= 2;
+				} else {
+					width /= 2;
+				}
 
-						uint32_t x = (quadrant & 1) * quadrant_size;
-						uint32_t y = (quadrant >> 1) * quadrant_size;
+				Transform proj = (p_view_transform.inverse() * light->transform).inverse();
 
-						uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
-						x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
-						y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+				Color light_clamp;
+				light_clamp[0] = float(x) / atlas_size;
+				light_clamp[1] = float(y) / atlas_size;
+				light_clamp[2] = float(width) / atlas_size;
+				light_clamp[3] = float(height) / atlas_size;
 
-						uint32_t width = shadow_size;
-						uint32_t height = shadow_size;
+				state.scene_shader.set_uniform(SceneShaderGLES2::SHADOW_PIXEL_SIZE, Size2(1.0 / shadow_atlas->size, 1.0 / shadow_atlas->size));
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX, proj);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
+			}
+		} break;
 
-						if (light->light_ptr->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
-							height /= 2;
-						} else {
-							width /= 2;
-						}
+		case VS::LIGHT_SPOT: {
 
-						Transform proj = (p_view_transform.inverse() * light->transform).inverse();
+			Vector3 position = p_view_transform.xform_inv(light->transform.origin);
 
-						Color light_clamp;
-						light_clamp[0] = float(x) / atlas_size;
-						light_clamp[1] = float(y) / atlas_size;
-						light_clamp[2] = float(width) / atlas_size;
-						light_clamp[3] = float(height) / atlas_size;
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_POSITION, position);
 
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX, proj);
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
+			Vector3 direction = p_view_transform.inverse().basis.xform(light->transform.basis.xform(Vector3(0, 0, -1))).normalized();
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_DIRECTION, direction);
+			Color attenuation = Color(0.0, 0.0, 0.0, 0.0);
+			attenuation.a = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
+			float range = light_ptr->param[VS::LIGHT_PARAM_RANGE];
+			float spot_attenuation = light_ptr->param[VS::LIGHT_PARAM_SPOT_ATTENUATION];
+			float angle = light_ptr->param[VS::LIGHT_PARAM_SPOT_ANGLE];
+			angle = Math::cos(Math::deg2rad(angle));
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ATTENUATION, attenuation);
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_ATTENUATION, spot_attenuation);
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_RANGE, spot_attenuation);
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_ANGLE, angle);
+			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_RANGE, range);
 
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 1.0);
-					} else {
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 0.0);
-					}
-				} break;
+			if (light->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(light->self)) {
+				uint32_t key = shadow_atlas->shadow_owners[light->self];
 
-				case VS::LIGHT_SPOT: {
-					Vector3 position = p_view_transform.inverse().xform(light->transform.origin);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_TYPE, (int)2);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_POSITION, position);
+				uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x03;
+				uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
 
-					Vector3 direction = p_view_transform.inverse().basis.xform(light->transform.basis.xform(Vector3(0, 0, -1))).normalized();
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_DIRECTION, direction);
-					Color attenuation = Color(0.0, 0.0, 0.0, 0.0);
-					attenuation.a = light_ptr->param[VS::LIGHT_PARAM_ATTENUATION];
-					float range = light_ptr->param[VS::LIGHT_PARAM_RANGE];
-					float spot_attenuation = light_ptr->param[VS::LIGHT_PARAM_SPOT_ATTENUATION];
-					float angle = light_ptr->param[VS::LIGHT_PARAM_SPOT_ANGLE];
-					angle = Math::cos(Math::deg2rad(angle));
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ATTENUATION, attenuation);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_ATTENUATION, spot_attenuation);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_RANGE, spot_attenuation);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPOT_ANGLE, angle);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_RANGE, range);
+				ERR_BREAK(shadow >= (uint32_t)shadow_atlas->quadrants[quadrant].shadows.size());
 
-					if (light->light_ptr->shadow && shadow_atlas && shadow_atlas->shadow_owners.has(light->self)) {
-						uint32_t key = shadow_atlas->shadow_owners[light->self];
+				uint32_t atlas_size = shadow_atlas->size;
+				uint32_t quadrant_size = atlas_size >> 1;
 
-						uint32_t quadrant = (key >> ShadowAtlas::QUADRANT_SHIFT) & 0x03;
-						uint32_t shadow = key & ShadowAtlas::SHADOW_INDEX_MASK;
+				uint32_t x = (quadrant & 1) * quadrant_size;
+				uint32_t y = (quadrant >> 1) * quadrant_size;
 
-						ERR_CONTINUE(shadow >= (uint32_t)shadow_atlas->quadrants[quadrant].shadows.size());
+				uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
+				x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+				y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
 
-						uint32_t atlas_size = shadow_atlas->size;
-						uint32_t quadrant_size = atlas_size >> 1;
+				uint32_t width = shadow_size;
+				uint32_t height = shadow_size;
 
-						uint32_t x = (quadrant & 1) * quadrant_size;
-						uint32_t y = (quadrant >> 1) * quadrant_size;
+				Rect2 rect(float(x) / atlas_size, float(y) / atlas_size, float(width) / atlas_size, float(height) / atlas_size);
 
-						uint32_t shadow_size = (quadrant_size / shadow_atlas->quadrants[quadrant].subdivision);
-						x += (shadow % shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
-						y += (shadow / shadow_atlas->quadrants[quadrant].subdivision) * shadow_size;
+				Color light_clamp;
+				light_clamp[0] = rect.position.x;
+				light_clamp[1] = rect.position.y;
+				light_clamp[2] = rect.size.x;
+				light_clamp[3] = rect.size.y;
 
-						uint32_t width = shadow_size;
-						uint32_t height = shadow_size;
+				Transform modelview = (p_view_transform.inverse() * light->transform).inverse();
 
-						Rect2 rect(float(x) / atlas_size, float(y) / atlas_size, float(width) / atlas_size, float(height) / atlas_size);
+				CameraMatrix bias;
+				bias.set_light_bias();
 
-						Color light_clamp;
-						light_clamp[0] = rect.position.x;
-						light_clamp[1] = rect.position.y;
-						light_clamp[2] = rect.size.x;
-						light_clamp[3] = rect.size.y;
+				CameraMatrix rectm;
+				rectm.set_light_atlas_rect(rect);
 
-						Transform modelview = (p_view_transform.inverse() * light->transform).inverse();
+				CameraMatrix shadow_matrix = rectm * bias * light->shadow_transform[0].camera * modelview;
 
-						CameraMatrix bias;
-						bias.set_light_bias();
+				state.scene_shader.set_uniform(SceneShaderGLES2::SHADOW_PIXEL_SIZE, Size2(1.0 / shadow_atlas->size, 1.0 / shadow_atlas->size));
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX, shadow_matrix);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
+			}
 
-						CameraMatrix rectm;
-						rectm.set_light_atlas_rect(rect);
+		} break;
 
-						CameraMatrix shadow_matrix = rectm * bias * light->shadow_transform[0].camera * modelview;
+		default: break;
+	}
+}
 
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 1.0);
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX, shadow_matrix);
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
+void RasterizerSceneGLES2::_render_render_list(RenderList::Element **p_elements, int p_element_count, const Transform &p_view_transform, const CameraMatrix &p_projection, RID p_shadow_atlas, Environment *p_env, GLuint p_base_env, float p_shadow_bias, float p_shadow_normal_bias, bool p_reverse_cull, bool p_alpha_pass, bool p_shadow) {
 
-					} else {
-						state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 0.0);
-					}
+	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
 
-				} break;
+	Vector2 screen_pixel_size;
+	screen_pixel_size.x = 1.0 / storage->frame.current_rt->width;
+	screen_pixel_size.y = 1.0 / storage->frame.current_rt->height;
 
-				default: break;
-			}
+	bool use_radiance_map = false;
+	if (!p_shadow && p_base_env) {
+		glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 2);
+		glBindTexture(GL_TEXTURE_CUBE_MAP, p_base_env);
+		use_radiance_map = true;
+		state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, true); //since prev unshaded is false, this needs to be true if exists
+	}
 
-			float energy = light->light_ptr->param[VS::LIGHT_PARAM_ENERGY];
-			float specular = light->light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+	bool prev_unshaded = false;
+	bool prev_instancing = false;
+	state.scene_shader.set_conditional(SceneShaderGLES2::SHADELESS, false);
+	RasterizerStorageGLES2::Material *prev_material = NULL;
+	RasterizerStorageGLES2::Geometry *prev_geometry = NULL;
+	RasterizerStorageGLES2::Skeleton *prev_skeleton = NULL;
 
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ENERGY, energy);
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_COLOR, light->light_ptr->color.to_linear());
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPECULAR, specular);
+	Transform view_transform_inverse = p_view_transform.inverse();
+	CameraMatrix projection_inverse = p_projection.inverse();
 
-			_render_geometry(e);
-		}
-	}
+	bool prev_base_pass = false;
+	LightInstance *prev_light = NULL;
+	bool prev_vertex_lit = false;
 
-	for (int dl = 0; dl < p_directional_light_count; dl++) {
-		RID light_rid = p_directional_lights[dl];
-		LightInstance *light = light_instance_owner.getornull(light_rid);
-		RasterizerStorageGLES2::Light *light_ptr = light->light_ptr;
+	int prev_blend_mode = -2; //will always catch the first go
 
-		switch (light_ptr->directional_shadow_mode) {
-			case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
-			} break;
-			case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
-				state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM2, true);
-				state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, light_ptr->directional_blend_splits);
-			} break;
+	if (p_alpha_pass) {
+		glEnable(GL_BLEND);
+	} else {
+		glDisable(GL_BLEND);
+	}
 
-			case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
-				state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM4, true);
-				state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, light_ptr->directional_blend_splits);
-			} break;
-			default:
-				break;
-		}
+	for (int i = 0; i < p_element_count; i++) {
+		RenderList::Element *e = p_elements[i];
 
-		for (int i = 0; i < p_element_count; i++) {
+		RasterizerStorageGLES2::Material *material = e->material;
 
-			RenderList::Element *e = p_elements[i];
-			RasterizerStorageGLES2::Material *material = e->material;
-			RasterizerStorageGLES2::Skeleton *skeleton = storage->skeleton_owner.getornull(e->instance->skeleton);
+		bool rebind = false;
+		bool accum_pass = *e->use_accum_ptr;
+		*e->use_accum_ptr = true; //set to accum for next time this is found
+		LightInstance *light = NULL;
 
-			{
-				_setup_material(material, p_reverse_cull, false, Size2i(skeleton ? skeleton->size * 3 : 0, 0));
+		if (!p_shadow) {
 
-				if (directional_shadow.depth) {
-					glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 4); // TODO move into base pass
-					glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
+			bool unshaded = material->shader->spatial.unshaded;
+
+			if (unshaded != prev_unshaded) {
+				rebind = true;
+				if (unshaded) {
+					state.scene_shader.set_conditional(SceneShaderGLES2::SHADELESS, true);
+					state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, false);
+					state.scene_shader.set_conditional(SceneShaderGLES2::USE_LIGHTING, false);
+				} else {
+					state.scene_shader.set_conditional(SceneShaderGLES2::SHADELESS, false);
+					state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, use_radiance_map);
 				}
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_MATRIX, p_view_transform.inverse());
-				state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_INVERSE_MATRIX, p_view_transform);
-				state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_MATRIX, p_projection);
-				state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_INVERSE_MATRIX, p_projection.inverse());
+				prev_unshaded = unshaded;
+			}
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::TIME, storage->frame.time[0]);
+			bool base_pass = !accum_pass && !unshaded; //conditions for a base pass
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::SCREEN_PIXEL_SIZE, screen_pixel_size);
-				state.scene_shader.set_uniform(SceneShaderGLES2::NORMAL_MULT, 1.0); // TODO mirror?
-				state.scene_shader.set_uniform(SceneShaderGLES2::WORLD_TRANSFORM, e->instance->transform);
+			if (base_pass != prev_base_pass) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::BASE_PASS, base_pass);
+				rebind = true;
+				prev_base_pass = base_pass;
 			}
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_TYPE, (int)0);
-			Vector3 direction = p_view_transform.inverse().basis.xform(light->transform.basis.xform(Vector3(0, 0, -1))).normalized();
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_DIRECTION, direction);
 
-			float energy = light_ptr->param[VS::LIGHT_PARAM_ENERGY];
-			float specular = light_ptr->param[VS::LIGHT_PARAM_SPECULAR];
+			if (!unshaded && e->light_index < RenderList::MAX_LIGHTS) {
+				light = render_light_instances[e->light_index];
+			}
 
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_ENERGY, energy);
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPECULAR, specular);
+			if (light != prev_light) {
 
-			float sign = light_ptr->negative ? -1 : 1;
+				_setup_light_type(light, shadow_atlas);
+				rebind = true;
+			}
 
-			Color linear_col = light_ptr->color.to_linear();
-			Color color;
-			for (int c = 0; c < 3; c++)
-				color[c] = linear_col[c] * sign * energy * Math_PI;
+			int blend_mode = p_alpha_pass ? material->shader->spatial.blend_mode : -1; // -1 no blend, no mix
 
-			color[3] = 0;
+			if (accum_pass) { //accum pass force pass
+				blend_mode = RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_ADD;
+			}
 
-			state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_COLOR, color);
+			if (prev_blend_mode != blend_mode) {
 
-			CameraMatrix matrices[4];
+				if (prev_blend_mode == -1 && blend_mode != -1) {
+					//does blend
+					glEnable(GL_BLEND);
+				} else if (blend_mode == -1 && prev_blend_mode != -1) {
+					//do not blend
+					glDisable(GL_BLEND);
+				}
 
-			if (light_ptr->shadow && directional_shadow.depth) {
+				switch (blend_mode) {
+					//-1 not handled because not blend is enabled anyway
+					case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_MIX: {
+						glBlendEquation(GL_FUNC_ADD);
+						if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+							glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+						} else {
+							glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+						}
 
-				int shadow_count = 0;
-				Color split_offsets;
+					} break;
+					case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_ADD: {
+
+						glBlendEquation(GL_FUNC_ADD);
+						glBlendFunc(p_alpha_pass ? GL_SRC_ALPHA : GL_ONE, GL_ONE);
 
-				switch (light_ptr->directional_shadow_mode) {
-					case VS::LIGHT_DIRECTIONAL_SHADOW_ORTHOGONAL: {
-						shadow_count = 1;
 					} break;
+					case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_SUB: {
 
-					case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS: {
-						shadow_count = 2;
+						glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+						glBlendFunc(GL_SRC_ALPHA, GL_ONE);
 					} break;
+					case RasterizerStorageGLES2::Shader::Spatial::BLEND_MODE_MUL: {
+						glBlendEquation(GL_FUNC_ADD);
+						if (storage->frame.current_rt && storage->frame.current_rt->flags[RasterizerStorage::RENDER_TARGET_TRANSPARENT]) {
+							glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_DST_ALPHA, GL_ZERO);
+						} else {
+							glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_ZERO, GL_ONE);
+						}
 
-					case VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS: {
-						shadow_count = 4;
 					} break;
 				}
 
-				for (int k = 0; k < shadow_count; k++) {
+				prev_blend_mode = blend_mode;
+			}
 
-					uint32_t x = light->directional_rect.position.x;
-					uint32_t y = light->directional_rect.position.y;
-					uint32_t width = light->directional_rect.size.x;
-					uint32_t height = light->directional_rect.size.y;
+			//condition to enable vertex lighting on this object
+			bool vertex_lit = light && (material->shader->spatial.uses_vertex_lighting || storage->config.force_vertex_shading) && !unshaded;
 
-					if (light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_4_SPLITS) {
+			if (vertex_lit != prev_vertex_lit) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_VERTEX_LIGHTING, vertex_lit);
+				prev_vertex_lit = vertex_lit;
+			}
+		}
 
-						width /= 2;
-						height /= 2;
+		bool instancing = e->instancing;
 
-						if (k == 0) {
+		if (instancing != prev_instancing) {
 
-						} else if (k == 1) {
-							x += width;
-						} else if (k == 2) {
-							y += height;
-						} else if (k == 3) {
-							x += width;
-							y += height;
-						}
+			state.scene_shader.set_conditional(SceneShaderGLES2::USE_INSTANCING, instancing);
+			rebind = true;
+		}
 
-					} else if (light_ptr->directional_shadow_mode == VS::LIGHT_DIRECTIONAL_SHADOW_PARALLEL_2_SPLITS) {
+		RasterizerStorageGLES2::Skeleton *skeleton = storage->skeleton_owner.getornull(e->instance->skeleton);
 
-						height /= 2;
+		if (skeleton != prev_skeleton) {
 
-						if (k == 0) {
+			if (skeleton) {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, skeleton != NULL);
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON_SOFTWARE, !storage->config.float_texture_supported);
+			} else {
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON, false);
+				state.scene_shader.set_conditional(SceneShaderGLES2::USE_SKELETON_SOFTWARE, false);
+			}
 
-						} else {
-							y += height;
-						}
-					}
+			rebind = true;
+		}
 
-					split_offsets[k] = light->shadow_transform[k].split;
+		if (e->geometry != prev_geometry || skeleton != prev_skeleton) {
+			_setup_geometry(e, skeleton);
+		}
 
-					Transform modelview = (p_view_transform * light->shadow_transform[k].transform).inverse();
+		bool shader_rebind = false;
+		if (rebind || material != prev_material) {
+			shader_rebind = _setup_material(material, p_reverse_cull, p_alpha_pass, Size2i(skeleton ? skeleton->size * 3 : 0, 0));
+		}
 
-					CameraMatrix bias;
-					bias.set_light_bias();
-					CameraMatrix rectm;
-					Rect2 atlas_rect = Rect2(float(x) / directional_shadow.size, float(y) / directional_shadow.size, float(width) / directional_shadow.size, float(height) / directional_shadow.size);
-					rectm.set_light_atlas_rect(atlas_rect);
+		if (i == 0 || shader_rebind) { //first time must rebindmakin
 
-					CameraMatrix shadow_mtx = rectm * bias * light->shadow_transform[k].camera * modelview;
-					matrices[k] = shadow_mtx.inverse();
+			if (p_shadow) {
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_BIAS, p_shadow_bias);
+				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_NORMAL_BIAS, p_shadow_normal_bias);
+				if (state.shadow_is_dual_parabolloid) {
+					state.scene_shader.set_uniform(SceneShaderGLES2::SHADOW_DUAL_PARABOLOID_RENDER_SIDE, state.dual_parbolloid_direction);
+					state.scene_shader.set_uniform(SceneShaderGLES2::SHADOW_DUAL_PARABOLOID_RENDER_ZFAR, state.dual_parbolloid_zfar);
+				}
+			} else {
+				if (use_radiance_map) {
+					state.scene_shader.set_uniform(SceneShaderGLES2::RADIANCE_INVERSE_XFORM, p_view_transform);
+				}
 
-					Color light_clamp;
-					light_clamp[0] = atlas_rect.position.x;
-					light_clamp[1] = atlas_rect.position.y;
-					light_clamp[2] = atlas_rect.size.x;
-					light_clamp[3] = atlas_rect.size.y;
+				if (p_env) {
+					state.scene_shader.set_uniform(SceneShaderGLES2::BG_ENERGY, p_env->bg_energy);
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_SKY_CONTRIBUTION, p_env->ambient_sky_contribution);
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_COLOR, p_env->ambient_color);
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_ENERGY, p_env->ambient_energy);
 
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 1.0);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_CLAMP, light_clamp);
-					state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SPLIT_OFFSETS, split_offsets);
+				} else {
+					state.scene_shader.set_uniform(SceneShaderGLES2::BG_ENERGY, 1.0);
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_SKY_CONTRIBUTION, 1.0);
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_COLOR, Color(1.0, 1.0, 1.0, 1.0));
+					state.scene_shader.set_uniform(SceneShaderGLES2::AMBIENT_ENERGY, 1.0);
 				}
 
-				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX1, matrices[0]);
-				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX2, matrices[1]);
-				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX3, matrices[2]);
-				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_SHADOW_MATRIX4, matrices[3]);
-			} else {
-				state.scene_shader.set_uniform(SceneShaderGLES2::LIGHT_HAS_SHADOW, 0.0);
+				if (light) {
+					_setup_light(light, shadow_atlas, p_view_transform);
+				}
 			}
 
-			_render_geometry(e);
+			state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_MATRIX, view_transform_inverse);
+			state.scene_shader.set_uniform(SceneShaderGLES2::CAMERA_INVERSE_MATRIX, p_view_transform);
+			state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_MATRIX, p_projection);
+			state.scene_shader.set_uniform(SceneShaderGLES2::PROJECTION_INVERSE_MATRIX, projection_inverse);
+
+			state.scene_shader.set_uniform(SceneShaderGLES2::TIME, storage->frame.time[0]);
+
+			state.scene_shader.set_uniform(SceneShaderGLES2::SCREEN_PIXEL_SIZE, screen_pixel_size);
+			state.scene_shader.set_uniform(SceneShaderGLES2::NORMAL_MULT, 1.0); // TODO mirror?
 		}
-	}
 
-	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_PASS, false);
+		state.scene_shader.set_uniform(SceneShaderGLES2::WORLD_TRANSFORM, e->instance->transform);
+
+		_render_geometry(e);
 
+		prev_geometry = e->geometry;
+		prev_material = material;
+		prev_skeleton = skeleton;
+		prev_instancing = instancing;
+		prev_light = light;
+	}
+
+	_setup_light_type(NULL, NULL); //clear light stuff
+	state.scene_shader.set_conditional(SceneShaderGLES2::SHADELESS, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::BASE_PASS, false);
 	state.scene_shader.set_conditional(SceneShaderGLES2::USE_RADIANCE_MAP, false);
 	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM4, false);
 	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM2, false);
 	state.scene_shader.set_conditional(SceneShaderGLES2::LIGHT_USE_PSSM_BLEND, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::USE_VERTEX_LIGHTING, false);
 }
 
 void RasterizerSceneGLES2::_draw_sky(RasterizerStorageGLES2::Sky *p_sky, const CameraMatrix &p_projection, const Transform &p_transform, bool p_vflip, float p_custom_fov, float p_energy) {
@@ -2013,6 +2111,38 @@ void RasterizerSceneGLES2::_draw_sky(RasterizerStorageGLES2::Sky *p_sky, const C
 
 void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID p_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass) {
 
+	//push back the directional lights
+
+	if (p_light_cull_count) {
+		//harcoded limit of 256 lights
+		render_light_instance_count = MIN(RenderList::MAX_LIGHTS, p_light_cull_count);
+		render_light_instances = (LightInstance **)alloca(sizeof(LightInstance *) * render_light_instance_count);
+		render_directional_lights = 0;
+
+		//doing this because directional lights are at the end, put them at the beginning
+		int index = 0;
+		for (int i = render_light_instance_count - 1; i >= 0; i--) {
+			RID light_rid = p_light_cull_result[i];
+
+			LightInstance *light = light_instance_owner.getornull(light_rid);
+
+			if (light->light_ptr->type == VS::LIGHT_DIRECTIONAL) {
+				render_directional_lights++;
+				//as goin in reverse, directional lights are always first anyway
+			}
+
+			light->light_index = index;
+			render_light_instances[index] = light;
+
+			index++;
+		}
+
+	} else {
+		render_light_instances = NULL;
+		render_directional_lights = 0;
+		render_light_instance_count = 0;
+	}
+
 	glEnable(GL_BLEND);
 
 	GLuint current_fb = storage->frame.current_rt->fbo;
@@ -2069,34 +2199,23 @@ void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const
 		}
 	}
 
-	Vector<RID> directional_lights;
-
-	for (int i = 0; i < p_light_cull_count; i++) {
-		RID light_rid = p_light_cull_result[i];
-
-		LightInstance *light = light_instance_owner.getornull(light_rid);
-
-		if (light->light_ptr->type == VS::LIGHT_DIRECTIONAL) {
-			directional_lights.push_back(light_rid);
-		}
-	}
-
 	// render opaque things first
 	render_list.sort_by_key(false);
-	_render_render_list(render_list.elements, render_list.element_count, directional_lights.ptr(), directional_lights.size(), p_cam_transform, p_cam_projection, p_shadow_atlas, env, env_radiance_tex, 0.0, 0.0, false, false, false, false);
+	_render_render_list(render_list.elements, render_list.element_count, p_cam_transform, p_cam_projection, p_shadow_atlas, env, env_radiance_tex, 0.0, 0.0, false, false, false);
 
 	// alpha pass
 
 	glBlendEquation(GL_FUNC_ADD);
 	glBlendFunc(GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
 
-	render_list.sort_by_key(true);
-	_render_render_list(&render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, directional_lights.ptr(), directional_lights.size(), p_cam_transform, p_cam_projection, p_shadow_atlas, env, env_radiance_tex, 0.0, 0.0, false, true, false, false);
+	render_list.sort_by_depth(true);
+
+	_render_render_list(&render_list.elements[render_list.max_elements - render_list.alpha_element_count], render_list.alpha_element_count, p_cam_transform, p_cam_projection, p_shadow_atlas, env, env_radiance_tex, 0.0, 0.0, false, true, false);
 
 	glDepthMask(GL_FALSE);
 	glDisable(GL_DEPTH_TEST);
 
-	// #define GLES2_SHADOW_ATLAS_DEBUG_VIEW
+	//#define GLES2_SHADOW_ATLAS_DEBUG_VIEW
 
 #ifdef GLES2_SHADOW_ATLAS_DEBUG_VIEW
 	ShadowAtlas *shadow_atlas = shadow_atlas_owner.getornull(p_shadow_atlas);
@@ -2115,6 +2234,25 @@ void RasterizerSceneGLES2::render_scene(const Transform &p_cam_transform, const
 		storage->_copy_screen();
 	}
 #endif
+
+	//#define GLES2_SHADOW_DIRECTIONAL_DEBUG_VIEW
+
+#ifdef GLES2_SHADOW_DIRECTIONAL_DEBUG_VIEW
+	if (true) {
+		glActiveTexture(GL_TEXTURE0);
+		glBindTexture(GL_TEXTURE_2D, directional_shadow.depth);
+
+		glViewport(0, 0, storage->frame.current_rt->width / 4, storage->frame.current_rt->height / 4);
+		storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_CUBEMAP, false);
+		storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_COPY_SECTION, false);
+		storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_CUSTOM_ALPHA, false);
+		storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_MULTIPLIER, false);
+		storage->shaders.copy.set_conditional(CopyShaderGLES2::USE_PANORAMA, false);
+		storage->shaders.copy.bind();
+
+		storage->_copy_screen();
+	}
+#endif
 }
 
 void RasterizerSceneGLES2::render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count) {
@@ -2134,8 +2272,9 @@ void RasterizerSceneGLES2::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 	float zfar = 0;
 	bool flip_facing = false;
 	int custom_vp_size = 0;
-
 	GLuint fbo = 0;
+	state.shadow_is_dual_parabolloid = false;
+	state.dual_parbolloid_direction = 0.0;
 
 	int current_cubemap = -1;
 	float bias = 0;
@@ -2264,8 +2403,32 @@ void RasterizerSceneGLES2::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 				zfar = light->param[VS::LIGHT_PARAM_RANGE];
 
 				current_cubemap = cubemap_index;
+			} else {
+				//dual parabolloid
+				state.shadow_is_dual_parabolloid = true;
+				light_projection = light_instance->shadow_transform[0].camera;
+				light_transform = light_instance->shadow_transform[0].transform;
+
+				if (light->omni_shadow_detail == VS::LIGHT_OMNI_SHADOW_DETAIL_HORIZONTAL) {
+
+					height /= 2;
+					y += p_pass * height;
+				} else {
+					width /= 2;
+					x += p_pass * width;
+				}
+
+				state.dual_parbolloid_direction = p_pass == 0 ? 1.0 : -1.0;
+				flip_facing = (p_pass == 1);
+				zfar = light->param[VS::LIGHT_PARAM_RANGE];
+				bias = light->param[VS::LIGHT_PARAM_SHADOW_BIAS];
+
+				state.dual_parbolloid_zfar = zfar;
+
+				state.scene_shader.set_conditional(SceneShaderGLES2::RENDER_DEPTH_DUAL_PARABOLOID, true);
 			}
-		} else {
+
+		} else if (light->type == VS::LIGHT_SPOT) {
 			light_projection = light_instance->shadow_transform[0].camera;
 			light_transform = light_instance->shadow_transform[0].transform;
 
@@ -2304,11 +2467,16 @@ void RasterizerSceneGLES2::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 	glClear(GL_DEPTH_BUFFER_BIT);
 	glDisable(GL_SCISSOR_TEST);
 
+	if (light->reverse_cull) {
+		flip_facing = !flip_facing;
+	}
+
 	state.scene_shader.set_conditional(SceneShaderGLES2::RENDER_DEPTH, true);
 
-	_render_render_list(render_list.elements, render_list.element_count, NULL, 0, light_transform, light_projection, RID(), NULL, 0, bias, normal_bias, false, false, true, false);
+	_render_render_list(render_list.elements, render_list.element_count, light_transform, light_projection, RID(), NULL, 0, bias, normal_bias, flip_facing, false, true);
 
 	state.scene_shader.set_conditional(SceneShaderGLES2::RENDER_DEPTH, false);
+	state.scene_shader.set_conditional(SceneShaderGLES2::RENDER_DEPTH_DUAL_PARABOLOID, false);
 
 	// convert cubemap to dual paraboloid if needed
 	if (light->type == VS::LIGHT_OMNI && light->omni_shadow_mode == VS::LIGHT_OMNI_SHADOW_CUBE && p_pass == 5) {
@@ -2358,6 +2526,7 @@ void RasterizerSceneGLES2::render_shadow(RID p_light, RID p_shadow_atlas, int p_
 	}
 
 	glViewport(0, 0, storage->frame.current_rt->width, storage->frame.current_rt->height);
+	glColorMask(1, 1, 1, 1);
 }
 
 void RasterizerSceneGLES2::set_scene_pass(uint64_t p_pass) {
@@ -2377,6 +2546,8 @@ void RasterizerSceneGLES2::initialize() {
 
 	render_list.init();
 
+	render_pass = 1;
+
 	shadow_atlas_realloc_tolerance_msec = 500;
 
 	{
@@ -2394,6 +2565,27 @@ void RasterizerSceneGLES2::initialize() {
 	}
 
 	{
+		default_worldcoord_shader = storage->shader_create();
+		storage->shader_set_code(default_worldcoord_shader, "shader_type spatial; render_mode world_vertex_coords;\n");
+		default_worldcoord_material = storage->material_create();
+		storage->material_set_shader(default_worldcoord_material, default_worldcoord_shader);
+
+		default_worldcoord_shader_twosided = storage->shader_create();
+		default_worldcoord_material_twosided = storage->material_create();
+		storage->shader_set_code(default_worldcoord_shader_twosided, "shader_type spatial; render_mode cull_disabled,world_vertex_coords;\n");
+		storage->material_set_shader(default_worldcoord_material_twosided, default_worldcoord_shader_twosided);
+	}
+
+	{
+		//default material and shader
+
+		default_overdraw_shader = storage->shader_create();
+		storage->shader_set_code(default_overdraw_shader, "shader_type spatial;\nrender_mode blend_add,unshaded;\n void fragment() { ALBEDO=vec3(0.4,0.8,0.8); ALPHA=0.2; }");
+		default_overdraw_material = storage->material_create();
+		storage->material_set_shader(default_overdraw_material, default_overdraw_shader);
+	}
+
+	{
 		glGenBuffers(1, &state.sky_verts);
 		glBindBuffer(GL_ARRAY_BUFFER, state.sky_verts);
 		glBufferData(GL_ARRAY_BUFFER, sizeof(Vector3) * 8, NULL, GL_DYNAMIC_DRAW);
@@ -2463,8 +2655,8 @@ void RasterizerSceneGLES2::initialize() {
 
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, directional_shadow.size, directional_shadow.size, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, NULL);
 
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
 
@@ -2475,9 +2667,16 @@ void RasterizerSceneGLES2::initialize() {
 			ERR_PRINT("Directional shadow framebuffer status invalid");
 		}
 	}
+
+	shadow_filter_mode = SHADOW_FILTER_NEAREST;
+
+	RenderList::Element e;
+	e.sort_key = 0;
+	e.light_type1 = 1;
 }
 
 void RasterizerSceneGLES2::iteration() {
+	shadow_filter_mode = ShadowFilterMode(int(GLOBAL_GET("rendering/quality/shadows/filter_mode")));
 }
 
 void RasterizerSceneGLES2::finalize() {
diff --git a/drivers/gles2/rasterizer_scene_gles2.h b/drivers/gles2/rasterizer_scene_gles2.h
index c5d28e55f4..27cbc35299 100644
--- a/drivers/gles2/rasterizer_scene_gles2.h
+++ b/drivers/gles2/rasterizer_scene_gles2.h
@@ -53,12 +53,34 @@
 
 class RasterizerSceneGLES2 : public RasterizerScene {
 public:
+	enum ShadowFilterMode {
+		SHADOW_FILTER_NEAREST,
+		SHADOW_FILTER_PCF5,
+		SHADOW_FILTER_PCF13,
+	};
+
+	ShadowFilterMode shadow_filter_mode;
+
 	RID default_material;
 	RID default_material_twosided;
 	RID default_shader;
 	RID default_shader_twosided;
 
+	RID default_worldcoord_material;
+	RID default_worldcoord_material_twosided;
+	RID default_worldcoord_shader;
+	RID default_worldcoord_shader_twosided;
+
+	RID default_overdraw_material;
+	RID default_overdraw_shader;
+
+	uint64_t render_pass;
 	uint64_t scene_pass;
+	uint32_t current_material_index;
+	uint32_t current_geometry_index;
+	uint32_t current_light_index;
+	uint32_t current_refprobe_index;
+	uint32_t current_shader_index;
 
 	RasterizerStorageGLES2 *storage;
 	struct State {
@@ -172,11 +194,16 @@ public:
 		bool cull_front;
 		bool cull_disabled;
 		bool used_sss;
-		bool used_screen_texture;
 		bool using_contact_shadows;
 
 		VS::ViewportDebugDraw debug_draw;
 		*/
+
+		bool used_screen_texture;
+		bool shadow_is_dual_parabolloid;
+		float dual_parbolloid_direction;
+		float dual_parbolloid_zfar;
+
 	} state;
 
 	/* SHADOW ATLAS API */
@@ -373,6 +400,10 @@ public:
 	virtual void light_instance_set_shadow_transform(RID p_light_instance, const CameraMatrix &p_projection, const Transform &p_transform, float p_far, float p_split, int p_pass, float p_bias_scale = 1.0);
 	virtual void light_instance_mark_visible(RID p_light_instance);
 
+	LightInstance **render_light_instances;
+	int render_directional_lights;
+	int render_light_instance_count;
+
 	/* REFLECTION INSTANCE */
 
 	virtual RID gi_probe_instance_create();
@@ -382,40 +413,18 @@ public:
 
 	/* RENDER LIST */
 
+	enum LightMode {
+		LIGHTMODE_NORMAL,
+		LIGHTMODE_UNSHADED,
+		LIGHTMODE_LIGHTMAP,
+		LIGHTMODE_LIGHTMAP_CAPTURE,
+	};
+
 	struct RenderList {
+
 		enum {
-			DEFAULT_MAX_ELEMENTS = 65536,
-			SORT_FLAG_SKELETON = 1,
-			SORT_FLAG_INSTANCING = 2,
-			MAX_DIRECTIONAL_LIGHTS = 16,
-			MAX_LIGHTS = 4096,
-			MAX_REFLECTIONS = 1024,
-
-			SORT_KEY_PRIORITY_SHIFT = 56,
-			SORT_KEY_PRIORITY_MASK = 0xFF,
-			//depth layer for opaque (56-52)
-			SORT_KEY_OPAQUE_DEPTH_LAYER_SHIFT = 52,
-			SORT_KEY_OPAQUE_DEPTH_LAYER_MASK = 0xF,
-//64 bits unsupported in MSVC
-#define SORT_KEY_UNSHADED_FLAG (uint64_t(1) << 49)
-#define SORT_KEY_NO_DIRECTIONAL_FLAG (uint64_t(1) << 48)
-#define SORT_KEY_LIGHTMAP_CAPTURE_FLAG (uint64_t(1) << 47)
-#define SORT_KEY_LIGHTMAP_FLAG (uint64_t(1) << 46)
-#define SORT_KEY_GI_PROBES_FLAG (uint64_t(1) << 45)
-#define SORT_KEY_VERTEX_LIT_FLAG (uint64_t(1) << 44)
-			SORT_KEY_SHADING_SHIFT = 44,
-			SORT_KEY_SHADING_MASK = 63,
-			//44-28 material index
-			SORT_KEY_MATERIAL_INDEX_SHIFT = 28,
-			//28-8 geometry index
-			SORT_KEY_GEOMETRY_INDEX_SHIFT = 8,
-			//bits 5-7 geometry type
-			SORT_KEY_GEOMETRY_TYPE_SHIFT = 5,
-			//bits 0-5 for flags
-			SORT_KEY_OPAQUE_PRE_PASS = 8,
-			SORT_KEY_CULL_DISABLED_FLAG = 4,
-			SORT_KEY_SKELETON_FLAG = 2,
-			SORT_KEY_MIRROR_FLAG = 1
+			MAX_LIGHTS = 255,
+			DEFAULT_MAX_ELEMENTS = 65536
 		};
 
 		int max_elements;
@@ -427,7 +436,38 @@ public:
 			RasterizerStorageGLES2::Material *material;
 			RasterizerStorageGLES2::GeometryOwner *owner;
 
-			uint64_t sort_key;
+			bool use_accum; //is this an add pass for multipass
+			bool *use_accum_ptr;
+
+			union {
+				//TODO: should be endian swapped on big endian
+				struct {
+					int32_t depth_layer : 16;
+					int32_t priority : 16;
+				};
+
+				uint32_t depth_key;
+			};
+
+			union {
+				struct {
+					//from least significant to most significant in sort, TODO: should be endian swapped on big endian
+
+					uint64_t geometry_index : 14;
+					uint64_t instancing : 1;
+					uint64_t skeleton : 1;
+					uint64_t shader_index : 10;
+					uint64_t material_index : 10;
+					uint64_t light_index : 8;
+					uint64_t light_type2 : 1; // if 1==0 : nolight/directional, else omni/spot
+					uint64_t refprobe_1_index : 8;
+					uint64_t refprobe_0_index : 8;
+					uint64_t light_type1 : 1; //no light, directional is 0, omni spot is 1
+					uint64_t light_mode : 2; // LightMode enum
+				};
+
+				uint64_t sort_key;
+			};
 		};
 
 		Element *base_elements;
@@ -445,7 +485,11 @@ public:
 
 		struct SortByKey {
 			_FORCE_INLINE_ bool operator()(const Element *A, const Element *B) const {
-				return A->sort_key < B->sort_key;
+				if (A->depth_key == B->depth_key) {
+					return A->sort_key < B->sort_key;
+				} else {
+					return A->depth_key < B->depth_key;
+				}
 			}
 		};
 
@@ -476,29 +520,6 @@ public:
 			}
 		}
 
-		struct SortByReverseDepthAndPriority {
-
-			_FORCE_INLINE_ bool operator()(const Element *A, const Element *B) const {
-				uint32_t layer_A = uint32_t(A->sort_key >> SORT_KEY_PRIORITY_SHIFT);
-				uint32_t layer_B = uint32_t(B->sort_key >> SORT_KEY_PRIORITY_SHIFT);
-				if (layer_A == layer_B) {
-					return A->instance->depth > B->instance->depth;
-				} else {
-					return layer_A < layer_B;
-				}
-			}
-		};
-
-		void sort_by_reverse_depth_and_priority(bool p_alpha) { //used for alpha
-
-			SortArray<Element *, SortByReverseDepthAndPriority> sorter;
-			if (p_alpha) {
-				sorter.sort(&elements[max_elements - alpha_element_count], alpha_element_count);
-			} else {
-				sorter.sort(elements, element_count);
-			}
-		}
-
 		// element adding and stuff
 
 		_FORCE_INLINE_ Element *add_element() {
@@ -549,7 +570,6 @@ public:
 
 	void _fill_render_list(InstanceBase **p_cull_result, int p_cull_count, bool p_depth_pass, bool p_shadow_pass);
 	void _render_render_list(RenderList::Element **p_elements, int p_element_count,
-			const RID *p_directional_lights, int p_directional_light_count,
 			const Transform &p_view_transform,
 			const CameraMatrix &p_projection,
 			RID p_shadow_atlas,
@@ -559,14 +579,15 @@ public:
 			float p_shadow_normal_bias,
 			bool p_reverse_cull,
 			bool p_alpha_pass,
-			bool p_shadow,
-			bool p_directional_add);
+			bool p_shadow);
 
 	void _draw_sky(RasterizerStorageGLES2::Sky *p_sky, const CameraMatrix &p_projection, const Transform &p_transform, bool p_vflip, float p_custom_fov, float p_energy);
 
-	void _setup_material(RasterizerStorageGLES2::Material *p_material, bool p_reverse_cull, bool p_alpha_pass, Size2i p_skeleton_tex_size = Size2i(0, 0));
-	void _setup_geometry(RenderList::Element *p_element, RasterizerStorageGLES2::Skeleton *p_skeleton);
-	void _render_geometry(RenderList::Element *p_element);
+	_FORCE_INLINE_ bool _setup_material(RasterizerStorageGLES2::Material *p_material, bool p_reverse_cull, bool p_alpha_pass, Size2i p_skeleton_tex_size = Size2i(0, 0));
+	_FORCE_INLINE_ void _setup_geometry(RenderList::Element *p_element, RasterizerStorageGLES2::Skeleton *p_skeleton);
+	_FORCE_INLINE_ void _setup_light_type(LightInstance *p_light, ShadowAtlas *shadow_atlas);
+	_FORCE_INLINE_ void _setup_light(LightInstance *p_light, ShadowAtlas *shadow_atlas, const Transform &p_view_transform);
+	_FORCE_INLINE_ void _render_geometry(RenderList::Element *p_element);
 
 	virtual void render_scene(const Transform &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_ortogonal, InstanceBase **p_cull_result, int p_cull_count, RID *p_light_cull_result, int p_light_cull_count, RID *p_reflection_probe_cull_result, int p_reflection_probe_cull_count, RID p_environment, RID p_shadow_atlas, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass);
 	virtual void render_shadow(RID p_light, RID p_shadow_atlas, int p_pass, InstanceBase **p_cull_result, int p_cull_count);
diff --git a/drivers/gles2/rasterizer_storage_gles2.cpp b/drivers/gles2/rasterizer_storage_gles2.cpp
index d945132dc2..b3ce873b65 100644
--- a/drivers/gles2/rasterizer_storage_gles2.cpp
+++ b/drivers/gles2/rasterizer_storage_gles2.cpp
@@ -52,6 +52,8 @@ GLuint RasterizerStorageGLES2::system_fbo = 0;
 #define _GL_HALF_FLOAT_OES 0x8D61
 #endif
 
+#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+
 void RasterizerStorageGLES2::bind_quad_array() const {
 	glBindBuffer(GL_ARRAY_BUFFER, resources.quadie);
 	glVertexAttribPointer(VS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0);
@@ -4225,6 +4227,12 @@ void RasterizerStorageGLES2::initialize() {
 
 		glBindTexture(GL_TEXTURE_2D, 0);
 	}
+
+#ifdef GLES_OVER_GL
+	glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
+#endif
+
+	config.force_vertex_shading = GLOBAL_GET("rendering/quality/shading/force_vertex_shading");
 }
 
 void RasterizerStorageGLES2::finalize() {
diff --git a/drivers/gles2/rasterizer_storage_gles2.h b/drivers/gles2/rasterizer_storage_gles2.h
index d9bf6b3ccb..e6708914ec 100644
--- a/drivers/gles2/rasterizer_storage_gles2.h
+++ b/drivers/gles2/rasterizer_storage_gles2.h
@@ -406,6 +406,9 @@ public:
 
 		String path;
 
+		uint32_t index;
+		uint64_t last_pass;
+
 		struct CanvasItem {
 
 			enum BlendMode {
@@ -491,6 +494,7 @@ public:
 			valid = false;
 			custom_code_id = 0;
 			version = 1;
+			last_pass = 0;
 		}
 	};
 
diff --git a/drivers/gles2/shader_compiler_gles2.cpp b/drivers/gles2/shader_compiler_gles2.cpp
index 83b61dc288..bedcfbb798 100644
--- a/drivers/gles2/shader_compiler_gles2.cpp
+++ b/drivers/gles2/shader_compiler_gles2.cpp
@@ -31,6 +31,7 @@
 #include "shader_compiler_gles2.h"
 
 #include "core/os/os.h"
+#include "core/project_settings.h"
 #include "core/string_buffer.h"
 #include "core/string_builder.h"
 
@@ -830,6 +831,7 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
 	actions[VS::SHADER_SPATIAL].renames["POINT_SIZE"] = "gl_PointSize";
 	// gl_InstanceID is not available in OpenGL ES 2.0
 	actions[VS::SHADER_SPATIAL].renames["INSTANCE_ID"] = "0";
+	actions[VS::SHADER_SPATIAL].renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";
 
 	//builtins
 
@@ -900,16 +902,30 @@ ShaderCompilerGLES2::ShaderCompilerGLES2() {
 	actions[VS::SHADER_SPATIAL].render_mode_defines["skip_vertex_transform"] = "#define SKIP_TRANSFORM_USED\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["world_vertex_coords"] = "#define VERTEX_WORLD_COORDS_USED\n";
 
-	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
+	bool force_lambert = GLOBAL_GET("rendering/quality/shading/force_lambert_over_burley");
+
+	if (!force_lambert) {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
+	}
+
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_oren_nayar"] = "#define DIFFUSE_OREN_NAYAR\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
 
-	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
+	bool force_blinn = GLOBAL_GET("rendering/quality/shading/force_blinn_over_ggx");
+
+	if (!force_blinn) {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
+	} else {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_BLINN\n";
+	}
+
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_blinn"] = "#define SPECULAR_BLINN\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_phong"] = "#define SPECULAR_PHONG\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_disabled"] = "#define SPECULAR_DISABLED\n";
+	actions[VS::SHADER_SPATIAL].render_mode_defines["shadows_disabled"] = "#define SHADOWS_DISABLED\n";
+	actions[VS::SHADER_SPATIAL].render_mode_defines["ambient_light_disabled"] = "#define AMBIENT_LIGHT_DISABLED\n";
 
 	/* PARTICLES SHADER */
 
diff --git a/drivers/gles2/shader_gles2.cpp b/drivers/gles2/shader_gles2.cpp
index 445428acc5..650e8f7c42 100644
--- a/drivers/gles2/shader_gles2.cpp
+++ b/drivers/gles2/shader_gles2.cpp
@@ -57,7 +57,7 @@
 
 ShaderGLES2 *ShaderGLES2::active = NULL;
 
-// #define DEBUG_SHADER
+//#define DEBUG_SHADER
 
 #ifdef DEBUG_SHADER
 
@@ -132,6 +132,11 @@ bool ShaderGLES2::bind() {
 
 	ERR_FAIL_COND_V(!version, false);
 
+	if (!version->ok) { //broken, unable to bind (do not throw error, you saw it before already when it failed compilation).
+		glUseProgram(0);
+		return false;
+	}
+
 	glUseProgram(version->id);
 
 	// find out uniform names and locations
@@ -171,72 +176,24 @@ void ShaderGLES2::unbind() {
 	active = NULL;
 }
 
-static String _fix_error_code_line(const String &p_error, int p_code_start, int p_offset) {
-
-	int last_find_pos = -1;
-	// NVIDIA
-	String error = p_error;
-	while ((last_find_pos = p_error.find("(", last_find_pos + 1)) != -1) {
-
-		int end_pos = last_find_pos + 1;
-
-		while (true) {
-
-			if (p_error[end_pos] >= '0' && p_error[end_pos] <= '9') {
-
-				end_pos++;
-				continue;
-			} else if (p_error[end_pos] == ')') {
-				break;
-			} else {
-
-				end_pos = -1;
-				break;
-			}
-		}
+static void _display_error_with_code(const String &p_error, const Vector<const char *> &p_code) {
 
-		if (end_pos == -1)
-			continue;
+	int line = 1;
+	String total_code;
 
-		String numstr = error.substr(last_find_pos + 1, (end_pos - last_find_pos) - 1);
-		String begin = error.substr(0, last_find_pos + 1);
-		String end = error.substr(end_pos, error.length());
-		int num = numstr.to_int() + p_code_start - p_offset;
-		error = begin + itos(num) + end;
+	for (int i = 0; i < p_code.size(); i++) {
+		total_code += String(p_code[i]);
 	}
 
-	// ATI
-	last_find_pos = -1;
-	while ((last_find_pos = p_error.find("ERROR: ", last_find_pos + 1)) != -1) {
-
-		last_find_pos += 6;
-		int end_pos = last_find_pos + 1;
+	Vector<String> lines = String(total_code).split("\n");
 
-		while (true) {
-
-			if (p_error[end_pos] >= '0' && p_error[end_pos] <= '9') {
-
-				end_pos++;
-				continue;
-			} else if (p_error[end_pos] == ':') {
-				break;
-			} else {
+	for (int j = 0; j < lines.size(); j++) {
 
-				end_pos = -1;
-				break;
-			}
-		}
-		continue;
-		if (end_pos == -1)
-			continue;
-
-		String numstr = error.substr(last_find_pos + 1, (end_pos - last_find_pos) - 1);
-		String begin = error.substr(0, last_find_pos + 1);
-		String end = error.substr(end_pos, error.length());
-		int num = numstr.to_int() + p_code_start - p_offset;
-		error = begin + itos(num) + end;
+		print_line(itos(line) + ": " + lines[j]);
+		line++;
 	}
-	return error;
+
+	ERR_PRINTS(p_error);
 }
 
 ShaderGLES2::Version *ShaderGLES2::get_current_version() {
@@ -316,7 +273,7 @@ ShaderGLES2::Version *ShaderGLES2::get_current_version() {
 	if (cc) {
 		for (int i = 0; i < cc->custom_defines.size(); i++) {
 			strings.push_back(cc->custom_defines.write[i]);
-			DEBUG_PRINT("CD #" + itos(i) + ": " + String(cc->custom_defines[i]));
+			DEBUG_PRINT("CD #" + itos(i) + ": " + String(cc->custom_defines[i].get_data()));
 		}
 	}
 
@@ -375,9 +332,8 @@ ShaderGLES2::Version *ShaderGLES2::get_current_version() {
 			String err_string = get_shader_name() + ": Vertex shader compilation failed:\n";
 
 			err_string += ilogmem;
-			err_string = _fix_error_code_line(err_string, vertex_code_start, define_line_ofs);
 
-			ERR_PRINTS(err_string);
+			_display_error_with_code(err_string, strings);
 
 			Memory::free_static(ilogmem);
 			glDeleteShader(v.vert_id);
@@ -451,9 +407,8 @@ ShaderGLES2::Version *ShaderGLES2::get_current_version() {
 			String err_string = get_shader_name() + ": Fragment shader compilation failed:\n";
 
 			err_string += ilogmem;
-			err_string = _fix_error_code_line(err_string, fragment_code_start, define_line_ofs);
 
-			ERR_PRINTS(err_string);
+			_display_error_with_code(err_string, strings);
 
 			Memory::free_static(ilogmem);
 			glDeleteShader(v.frag_id);
@@ -503,9 +458,8 @@ ShaderGLES2::Version *ShaderGLES2::get_current_version() {
 		String err_string = get_shader_name() + ": Program linking failed:\n";
 
 		err_string += ilogmem;
-		err_string = _fix_error_code_line(err_string, fragment_code_start, define_line_ofs);
 
-		ERR_PRINTS(err_string);
+		_display_error_with_code(err_string, strings);
 
 		Memory::free_static(ilogmem);
 		glDeleteShader(v.frag_id);
diff --git a/drivers/gles2/shader_gles2.h b/drivers/gles2/shader_gles2.h
index 8e274b4f57..78e1962f80 100644
--- a/drivers/gles2/shader_gles2.h
+++ b/drivers/gles2/shader_gles2.h
@@ -468,7 +468,8 @@ public:
 	// like forward declared nested classes.
 	void use_material(void *p_material);
 
-	uint32_t get_version() const { return new_conditional_version.version; }
+	_FORCE_INLINE_ uint32_t get_version() const { return new_conditional_version.version; }
+	_FORCE_INLINE_ bool is_version_valid() const { return version && version->ok; }
 
 	void set_uniform_camera(int p_idx, const CameraMatrix &p_mat) {
 
diff --git a/drivers/gles2/shaders/scene.glsl b/drivers/gles2/shaders/scene.glsl
index 906c089170..fa8063b3dd 100644
--- a/drivers/gles2/shaders/scene.glsl
+++ b/drivers/gles2/shaders/scene.glsl
@@ -5,12 +5,16 @@
 #define mediump
 #define highp
 #else
-precision mediump float;
-precision mediump int;
+precision highp float;
+precision highp int;
 #endif
 
 #include "stdlib.glsl"
 
+#define SHADER_IS_SRGB true
+
+#define M_PI 3.14159265359
+
 //
 // attributes
 //
@@ -39,9 +43,9 @@ attribute vec2 uv2_attrib; // attrib:5
 
 #ifdef USE_SKELETON_SOFTWARE
 
-attribute highp vec4 bone_transform_row_0; // attrib:9
-attribute highp vec4 bone_transform_row_1; // attrib:10
-attribute highp vec4 bone_transform_row_2; // attrib:11
+attribute highp vec4 bone_transform_row_0; // attrib:8
+attribute highp vec4 bone_transform_row_1; // attrib:9
+attribute highp vec4 bone_transform_row_2; // attrib:10
 
 #else
 
@@ -57,12 +61,12 @@ uniform ivec2 skeleton_texture_size;
 
 #ifdef USE_INSTANCING
 
-attribute highp vec4 instance_xform_row_0; // attrib:12
-attribute highp vec4 instance_xform_row_1; // attrib:13
-attribute highp vec4 instance_xform_row_2; // attrib:14
+attribute highp vec4 instance_xform_row_0; // attrib:8
+attribute highp vec4 instance_xform_row_1; // attrib:9
+attribute highp vec4 instance_xform_row_2; // attrib:10
 
-attribute highp vec4 instance_color; // attrib:15
-attribute highp vec4 instance_custom_data; // attrib:8
+attribute highp vec4 instance_color; // attrib:11
+attribute highp vec4 instance_custom_data; // attrib:12
 
 #endif
 
@@ -116,6 +120,155 @@ VERTEX_SHADER_GLOBALS
 
 /* clang-format on */
 
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+varying highp float dp_clip;
+uniform highp float shadow_dual_paraboloid_render_zfar;
+uniform highp float shadow_dual_paraboloid_render_side;
+
+#endif
+
+#if defined(USE_SHADOW) && defined(USE_LIGHTING)
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+uniform highp sampler2D light_directional_shadow; // texunit:-3
+uniform highp vec4 light_split_offsets;
+#endif
+
+
+uniform highp mat4 light_shadow_matrix;
+varying highp vec4 shadow_coord;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+uniform highp mat4 light_shadow_matrix2;
+varying highp vec4 shadow_coord2;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+
+uniform highp mat4 light_shadow_matrix3;
+uniform highp mat4 light_shadow_matrix4;
+varying highp vec4 shadow_coord3;
+varying highp vec4 shadow_coord4;
+
+#endif
+
+#endif
+
+
+#if defined(USE_VERTEX_LIGHTING) && defined(USE_LIGHTING)
+
+varying highp vec3 diffuse_interp;
+varying highp vec3 specular_interp;
+
+// general for all lights
+uniform vec4 light_color;
+uniform float light_specular;
+
+// directional
+uniform vec3 light_direction;
+
+// omni
+uniform vec3 light_position;
+
+uniform float light_range;
+uniform vec4 light_attenuation;
+
+// spot
+uniform float light_spot_attenuation;
+uniform float light_spot_range;
+uniform float light_spot_angle;
+
+void light_compute(
+		vec3 N,
+		vec3 L,
+		vec3 V,
+		vec3 light_color,
+		vec3 attenuation,
+		float roughness) {
+
+//this makes lights behave closer to linear, but then addition of lights looks bad
+//better left disabled
+
+//#define SRGB_APPROX(m_var) m_var = pow(m_var,0.4545454545);
+/*
+#define SRGB_APPROX(m_var) {\
+	float S1 = sqrt(m_var);\
+	float S2 = sqrt(S1);\
+	float S3 = sqrt(S2);\
+	m_var = 0.662002687 * S1 + 0.684122060 * S2 - 0.323583601 * S3 - 0.0225411470 * m_var;\
+	}
+*/
+#define SRGB_APPROX(m_var)
+
+	float NdotL = dot(N, L);
+	float cNdotL = max(NdotL, 0.0); // clamped NdotL
+	float NdotV = dot(N, V);
+	float cNdotV = max(NdotV, 0.0);
+
+
+#if defined(DIFFUSE_OREN_NAYAR)
+	vec3 diffuse_brdf_NL;
+#else
+	float diffuse_brdf_NL; // BRDF times N.L for calculating diffuse radiance
+#endif
+
+#if defined(DIFFUSE_LAMBERT_WRAP)
+		// energy conserving lambert wrap shader
+	diffuse_brdf_NL = max(0.0, (NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
+
+#elif defined(DIFFUSE_OREN_NAYAR)
+
+	{
+		// see http://mimosa-pudica.net/improved-oren-nayar.html
+		float LdotV = dot(L, V);
+
+		float s = LdotV - NdotL * NdotV;
+		float t = mix(1.0, max(NdotL, NdotV), step(0.0, s));
+
+		float sigma2 = roughness * roughness; // TODO: this needs checking
+		vec3 A = 1.0 + sigma2 * (-0.5 / (sigma2 + 0.33) + 0.17 * diffuse_color / (sigma2 + 0.13));
+		float B = 0.45 * sigma2 / (sigma2 + 0.09);
+
+		diffuse_brdf_NL = cNdotL * (A + vec3(B) * s / t) * (1.0 / M_PI);
+	}
+#else
+		// lambert by default for everything else
+	diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
+#endif
+
+	SRGB_APPROX(diffuse_brdf_NL)
+
+	diffuse_interp += light_color * diffuse_brdf_NL * attenuation;
+
+
+
+	if (roughness > 0.0) {
+
+		// D
+		float specular_brdf_NL = 0.0;
+
+#if !defined(SPECULAR_DISABLED)
+		//normalized blinn always unless disabled
+		vec3 H = normalize(V + L);
+		float cNdotH = max(dot(N, H), 0.0);
+		float cVdotH = max(dot(V, H), 0.0);
+		float cLdotH = max(dot(L, H), 0.0);
+		float shininess = exp2( 15.0 * (1.0 - roughness) + 1.0 ) * 0.25;
+		float blinn = pow( cNdotH, shininess );
+		blinn *= (shininess + 8.0) / (8.0 * 3.141592654);
+		specular_brdf_NL = ( blinn ) / max( 4.0 * cNdotV * cNdotL, 0.75 );
+#endif
+
+		SRGB_APPROX(specular_brdf_NL)
+		specular_interp += specular_brdf_NL * light_color * attenuation;
+
+	}
+
+}
+
+#endif
+
 void main() {
 
 	highp vec4 vertex = vertex_attrib;
@@ -209,6 +362,8 @@ void main() {
 #endif
 
 	mat4 modelview = camera_matrix * world_matrix;
+	float roughness = 1.0;
+
 
 #define world_transform world_matrix
 
@@ -252,13 +407,106 @@ VERTEX_SHADER_CODE
 
 #ifdef RENDER_DEPTH
 
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	vertex_interp.z *= shadow_dual_paraboloid_render_side;
+	normal_interp.z *= shadow_dual_paraboloid_render_side;
+
+	dp_clip = vertex_interp.z; //this attempts to avoid noise caused by objects sent to the other parabolloid side due to bias
+
+	//for dual paraboloid shadow mapping, this is the fastest but least correct way, as it curves straight edges
+
+	highp vec3 vtx = vertex_interp + normalize(vertex_interp) * light_bias;
+	highp float distance = length(vtx);
+	vtx = normalize(vtx);
+	vtx.xy /= 1.0 - vtx.z;
+	vtx.z = (distance / shadow_dual_paraboloid_render_zfar);
+	vtx.z = vtx.z * 2.0 - 1.0;
+
+	vertex_interp = vtx;
+
+#else
 	float z_ofs = light_bias;
 	z_ofs += (1.0 - abs(normal_interp.z)) * light_normal_bias;
 
 	vertex_interp.z -= z_ofs;
+#endif //dual parabolloid
+
+#endif //depth
+
+
+//vertex lighting
+#if defined(USE_VERTEX_LIGHTING) && defined(USE_LIGHTING)
+	//vertex shaded version of lighting (more limited)
+	vec3 L;
+	vec3 light_att;
+
+#ifdef LIGHT_MODE_OMNI
+	vec3 light_vec = light_position - vertex_interp;
+	float light_length = length(light_vec);
+
+	float normalized_distance = light_length / light_range;
+
+	float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
+
+	vec3 attenuation = vec3(omni_attenuation);
+	light_att=vec3(omni_attenuation);
+
+	L = normalize(light_vec);
+
+#endif
+
+#ifdef LIGHT_MODE_SPOT
+
+	vec3 light_rel_vec = light_position - vertex_interp;
+	float light_length = length(light_rel_vec);
+	float normalized_distance = light_length / light_range;
+
+	float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
+	vec3 spot_dir = light_direction;
+
+	float spot_cutoff = light_spot_angle;
+
+	float scos = max(dot(-normalize(light_rel_vec), spot_dir), spot_cutoff);
+	float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));
+
+	spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);
+
+	light_att = vec3(spot_attenuation);
+	L = normalize(light_rel_vec);
+
+#endif
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+	vec3 light_vec = -light_direction;
+	light_att = vec3(1.0); //no base attenuation
+	L = normalize(light_vec);
+#endif
+
+	diffuse_interp = vec3(0.0);
+	specular_interp = vec3(0.0);
+	light_compute(normal_interp,L,-normalize(vertex_interp),light_color.rgb,light_att,roughness);
+
+#endif
+
+//shadows (for both vertex and fragment)
+#if defined(USE_SHADOW) && defined(USE_LIGHTING)
+
+	vec4 vi4 = vec4(vertex_interp,1.0);
+	shadow_coord = light_shadow_matrix * vi4;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+	shadow_coord2 = light_shadow_matrix2 * vi4;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+	shadow_coord3 = light_shadow_matrix3 * vi4;
+	shadow_coord3 = light_shadow_matrix3 * vi4;
 
 #endif
 
+#endif //use shadow and use lighting
+
 	gl_Position = projection_matrix * vec4(vertex_interp, 1.0);
 }
 
@@ -276,12 +524,13 @@ VERTEX_SHADER_CODE
 #define highp
 #else
 precision mediump float;
-precision mediump int;
+precision highp int;
 #endif
 
 #include "stdlib.glsl"
 
 #define M_PI 3.14159265359
+#define SHADER_IS_SRGB true
 
 //
 // uniforms
@@ -301,10 +550,11 @@ uniform highp float time;
 uniform vec2 screen_pixel_size;
 #endif
 
-uniform highp sampler2D depth_buffer; //texunit:-5
+// I think supporting this in GLES2 is difficult
+// uniform highp sampler2D depth_buffer;
 
 #if defined(SCREEN_TEXTURE_USED)
-uniform highp sampler2D screen_texture; //texunit:-6
+uniform highp sampler2D screen_texture; //texunit:-4
 #endif
 
 #ifdef USE_RADIANCE_MAP
@@ -323,49 +573,69 @@ uniform float ambient_sky_contribution;
 uniform vec4 ambient_color;
 uniform float ambient_energy;
 
-#ifdef LIGHT_PASS
+#ifdef USE_LIGHTING
 
-#define LIGHT_TYPE_DIRECTIONAL 0
-#define LIGHT_TYPE_OMNI 1
-#define LIGHT_TYPE_SPOT 2
+#ifdef USE_VERTEX_LIGHTING
 
-// general for all lights
-uniform int light_type;
+//get from vertex
+varying highp vec3 diffuse_interp;
+varying highp vec3 specular_interp;
 
-uniform float light_energy;
+#else
+//done in fragment
+// general for all lights
 uniform vec4 light_color;
 uniform float light_specular;
 
 // directional
 uniform vec3 light_direction;
-
 // omni
 uniform vec3 light_position;
 
-uniform float light_range;
 uniform vec4 light_attenuation;
 
 // spot
 uniform float light_spot_attenuation;
 uniform float light_spot_range;
 uniform float light_spot_angle;
+#endif
 
-// shadows
-uniform highp sampler2D light_shadow_atlas; //texunit:-4
-uniform float light_has_shadow;
+//this is needed outside above if because dual paraboloid wants it
+uniform float light_range;
+
+#ifdef USE_SHADOW
+
+uniform highp vec2 shadow_pixel_size;
+
+#if defined(LIGHT_MODE_OMNI) || defined(LIGHT_MODE_SPOT)
+uniform highp sampler2D light_shadow_atlas; //texunit:-3
+#endif
+
+#ifdef LIGHT_MODE_DIRECTIONAL
+uniform highp sampler2D light_directional_shadow; // texunit:-3
+uniform highp vec4 light_split_offsets;
+#endif
+
+
+varying highp vec4 shadow_coord;
+
+#if defined(LIGHT_USE_PSSM2) || defined(LIGHT_USE_PSSM4)
+varying highp vec4 shadow_coord2;
+#endif
+
+#if defined(LIGHT_USE_PSSM4)
+
+varying highp vec4 shadow_coord3;
+varying highp vec4 shadow_coord4;
+
+#endif
 
-uniform mat4 light_shadow_matrix;
 uniform vec4 light_clamp;
 
-// directional shadow
+#endif // light shadow
 
-uniform highp sampler2D light_directional_shadow; // texunit:-4
-uniform vec4 light_split_offsets;
+// directional shadow
 
-uniform mat4 light_shadow_matrix1;
-uniform mat4 light_shadow_matrix2;
-uniform mat4 light_shadow_matrix3;
-uniform mat4 light_shadow_matrix4;
 #endif
 
 //
@@ -406,7 +676,80 @@ FRAGMENT_SHADER_GLOBALS
 
 /* clang-format on */
 
-#ifdef LIGHT_PASS
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+varying highp float dp_clip;
+
+#endif
+
+#ifdef USE_LIGHTING
+
+
+// This returns the G_GGX function divided by 2 cos_theta_m, where in practice cos_theta_m is either N.L or N.V.
+// We're dividing this factor off because the overall term we'll end up looks like
+// (see, for example, the first unnumbered equation in B. Burley, "Physically Based Shading at Disney", SIGGRAPH 2012):
+//
+//   F(L.V) D(N.H) G(N.L) G(N.V) / (4 N.L N.V)
+//
+// We're basically regouping this as
+//
+//   F(L.V) D(N.H) [G(N.L)/(2 N.L)] [G(N.V) / (2 N.V)]
+//
+// and thus, this function implements the [G(N.m)/(2 N.m)] part with m = L or V.
+//
+// The contents of the D and G (G1) functions (GGX) are taken from
+// E. Heitz, "Understanding the Masking-Shadowing Function in Microfacet-Based BRDFs", J. Comp. Graph. Tech. 3 (2) (2014).
+// Eqns 71-72 and 85-86 (see also Eqns 43 and 80).
+
+float G_GGX_2cos(float cos_theta_m, float alpha) {
+	// Schlick's approximation
+	// C. Schlick, "An Inexpensive BRDF Model for Physically-based Rendering", Computer Graphics Forum. 13 (3): 233 (1994)
+	// Eq. (19), although see Heitz (2014) the about the problems with his derivation.
+	// It nevertheless approximates GGX well with k = alpha/2.
+	float k = 0.5 * alpha;
+	return 0.5 / (cos_theta_m * (1.0 - k) + k);
+
+	// float cos2 = cos_theta_m * cos_theta_m;
+	// float sin2 = (1.0 - cos2);
+	// return 1.0 / (cos_theta_m + sqrt(cos2 + alpha * alpha * sin2));
+}
+
+float D_GGX(float cos_theta_m, float alpha) {
+	float alpha2 = alpha * alpha;
+	float d = 1.0 + (alpha2 - 1.0) * cos_theta_m * cos_theta_m;
+	return alpha2 / (M_PI * d * d);
+}
+
+float G_GGX_anisotropic_2cos(float cos_theta_m, float alpha_x, float alpha_y, float cos_phi, float sin_phi) {
+	float cos2 = cos_theta_m * cos_theta_m;
+	float sin2 = (1.0 - cos2);
+	float s_x = alpha_x * cos_phi;
+	float s_y = alpha_y * sin_phi;
+	return 1.0 / max(cos_theta_m + sqrt(cos2 + (s_x * s_x + s_y * s_y) * sin2), 0.001);
+}
+
+float D_GGX_anisotropic(float cos_theta_m, float alpha_x, float alpha_y, float cos_phi, float sin_phi) {
+	float cos2 = cos_theta_m * cos_theta_m;
+	float sin2 = (1.0 - cos2);
+	float r_x = cos_phi / alpha_x;
+	float r_y = sin_phi / alpha_y;
+	float d = cos2 + sin2 * (r_x * r_x + r_y * r_y);
+	return 1.0 / max(M_PI * alpha_x * alpha_y * d * d, 0.001);
+}
+
+float SchlickFresnel(float u) {
+	float m = 1.0 - u;
+	float m2 = m * m;
+	return m2 * m2 * m; // pow(m,5)
+}
+
+float GTR1(float NdotH, float a) {
+	if (a >= 1.0) return 1.0 / M_PI;
+	float a2 = a * a;
+	float t = 1.0 + (a2 - 1.0) * NdotH * NdotH;
+	return (a2 - 1.0) / (M_PI * log(a2) * t);
+}
+
 void light_compute(
 		vec3 N,
 		vec3 L,
@@ -428,52 +771,274 @@ void light_compute(
 		inout vec3 diffuse_light,
 		inout vec3 specular_light) {
 
+//this makes lights behave closer to linear, but then addition of lights looks bad
+//better left disabled
+
+//#define SRGB_APPROX(m_var) m_var = pow(m_var,0.4545454545);
+/*
+#define SRGB_APPROX(m_var) {\
+	float S1 = sqrt(m_var);\
+	float S2 = sqrt(S1);\
+	float S3 = sqrt(S2);\
+	m_var = 0.662002687 * S1 + 0.684122060 * S2 - 0.323583601 * S3 - 0.0225411470 * m_var;\
+	}
+*/
+#define SRGB_APPROX(m_var)
+
+#if defined(USE_LIGHT_SHADER_CODE)
+	// light is written by the light shader
+
+	vec3 normal = N;
+	vec3 albedo = diffuse_color;
+	vec3 light = L;
+	vec3 view = V;
+
+	/* clang-format off */
+
+LIGHT_SHADER_CODE
+
+	/* clang-format on */
+
+#else
 	float NdotL = dot(N, L);
-	float cNdotL = max(NdotL, 0.0);
+	float cNdotL = max(NdotL, 0.0); // clamped NdotL
 	float NdotV = dot(N, V);
 	float cNdotV = max(NdotV, 0.0);
 
-	{
-		// calculate diffuse reflection
-
-		// TODO hardcode Oren Nayar for now
-		float diffuse_brdf_NL;
+	if (metallic < 1.0) {
+#if defined(DIFFUSE_OREN_NAYAR)
+		vec3 diffuse_brdf_NL;
+#else
+		float diffuse_brdf_NL; // BRDF times N.L for calculating diffuse radiance
+#endif
 
+#if defined(DIFFUSE_LAMBERT_WRAP)
+		// energy conserving lambert wrap shader
 		diffuse_brdf_NL = max(0.0, (NdotL + roughness) / ((1.0 + roughness) * (1.0 + roughness)));
-		// diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
+
+#elif defined(DIFFUSE_OREN_NAYAR)
+
+		{
+			// see http://mimosa-pudica.net/improved-oren-nayar.html
+			float LdotV = dot(L, V);
+
+			float s = LdotV - NdotL * NdotV;
+			float t = mix(1.0, max(NdotL, NdotV), step(0.0, s));
+
+			float sigma2 = roughness * roughness; // TODO: this needs checking
+			vec3 A = 1.0 + sigma2 * (-0.5 / (sigma2 + 0.33) + 0.17 * diffuse_color / (sigma2 + 0.13));
+			float B = 0.45 * sigma2 / (sigma2 + 0.09);
+
+			diffuse_brdf_NL = cNdotL * (A + vec3(B) * s / t) * (1.0 / M_PI);
+		}
+
+#elif defined(DIFFUSE_TOON)
+
+		diffuse_brdf_NL = smoothstep(-roughness, max(roughness, 0.01), NdotL);
+
+#elif defined(DIFFUSE_BURLEY)
+
+		{
+
+			vec3 H = normalize(V + L);
+			float cLdotH = max(0.0, dot(L, H));
+
+			float FD90 = 0.5 + 2.0 * cLdotH * cLdotH * roughness;
+			float FdV = 1.0 + (FD90 - 1.0) * SchlickFresnel(cNdotV);
+			float FdL = 1.0 + (FD90 - 1.0) * SchlickFresnel(cNdotL);
+			diffuse_brdf_NL = (1.0 / M_PI) * FdV * FdL * cNdotL;
+			/*
+			float energyBias = mix(roughness, 0.0, 0.5);
+			float energyFactor = mix(roughness, 1.0, 1.0 / 1.51);
+			float fd90 = energyBias + 2.0 * VoH * VoH * roughness;
+			float f0 = 1.0;
+			float lightScatter = f0 + (fd90 - f0) * pow(1.0 - cNdotL, 5.0);
+			float viewScatter = f0 + (fd90 - f0) * pow(1.0 - cNdotV, 5.0);
+
+			diffuse_brdf_NL = lightScatter * viewScatter * energyFactor;
+			*/
+		}
+#else
+		// lambert
+		diffuse_brdf_NL = cNdotL * (1.0 / M_PI);
+#endif
+
+		SRGB_APPROX(diffuse_brdf_NL)
 
 		diffuse_light += light_color * diffuse_color * diffuse_brdf_NL * attenuation;
+
+#if defined(TRANSMISSION_USED)
+		diffuse_light += light_color * diffuse_color * (vec3(1.0 / M_PI) - diffuse_brdf_NL) * transmission * attenuation;
+#endif
+
+#if defined(LIGHT_USE_RIM)
+		float rim_light = pow(max(0.0, 1.0 - cNdotV), max(0.0, (1.0 - roughness) * 16.0));
+		diffuse_light += rim_light * rim * mix(vec3(1.0), diffuse_color, rim_tint) * light_color;
+#endif
 	}
 
-	{
-		// calculate specular reflection
+	if (roughness > 0.0) {
+
+		// D
+
+		float specular_brdf_NL;
+
+#if defined(SPECULAR_BLINN)
+
+		//normalized blinn
+		vec3 H = normalize(V + L);
+		float cNdotH = max(dot(N, H), 0.0);
+		float cVdotH = max(dot(V, H), 0.0);
+		float cLdotH = max(dot(L, H), 0.0);
+		float shininess = exp2( 15.0 * (1.0 - roughness) + 1.0 ) * 0.25;
+		float blinn = pow( cNdotH, shininess );
+		blinn *= (shininess + 8.0) / (8.0 * 3.141592654);
+		specular_brdf_NL = ( blinn ) / max( 4.0 * cNdotV * cNdotL, 0.75 );
+
+#elif defined(SPECULAR_PHONG)
+
+		vec3 R = normalize(-reflect(L, N));
+		float cRdotV = max(0.0, dot(R, V));
+		float shininess = exp2( 15.0 * (1.0 - roughness) + 1.0 ) * 0.25;
+		float phong = pow( cRdotV, shininess );
+		phong *= (shininess + 8.0) / (8.0 * 3.141592654);
+		specular_brdf_NL = ( phong ) / max( 4.0 * cNdotV * cNdotL, 0.75 );
+
+
+
+#elif defined(SPECULAR_TOON)
 
 		vec3 R = normalize(-reflect(L, N));
-		float cRdotV = max(dot(R, V), 0.0);
-		float blob_intensity = pow(cRdotV, (1.0 - roughness) * 256.0);
-		specular_light += light_color * attenuation * blob_intensity * specular_blob_intensity;
+		float RdotV = dot(R, V);
+		float mid = 1.0 - roughness;
+		mid *= mid;
+		specular_brdf_NL = smoothstep(mid - roughness * 0.5, mid + roughness * 0.5, RdotV) * mid;
+
+#elif defined(SPECULAR_DISABLED)
+		// none..
+		specular_brdf_NL = 0.0;
+#elif defined(SPECULAR_SCHLICK_GGX)
+		// shlick+ggx as default
+
+		vec3 H = normalize(V + L);
+
+		float cNdotH = max(dot(N, H), 0.0);
+		float cLdotH = max(dot(L, H), 0.0);
+
+#if defined(LIGHT_USE_ANISOTROPY)
+
+		float aspect = sqrt(1.0 - anisotropy * 0.9);
+		float rx = roughness / aspect;
+		float ry = roughness * aspect;
+		float ax = rx * rx;
+		float ay = ry * ry;
+		float XdotH = dot(T, H);
+		float YdotH = dot(B, H);
+		float D = D_GGX_anisotropic(cNdotH, ax, ay, XdotH, YdotH);
+		float G = G_GGX_anisotropic_2cos(cNdotL, ax, ay, XdotH, YdotH) * G_GGX_anisotropic_2cos(cNdotV, ax, ay, XdotH, YdotH);
+
+#else
+		float alpha = roughness * roughness;
+		float D = D_GGX(cNdotH, alpha);
+		float G = G_GGX_2cos(cNdotL, alpha) * G_GGX_2cos(cNdotV, alpha);
+#endif
+		// F
+		//float F0 = 1.0;
+		//float cLdotH5 = SchlickFresnel(cLdotH);
+		//float F = mix(cLdotH5, 1.0, F0);
+
+		specular_brdf_NL = cNdotL * D /* F */ * G;
+
+#endif
+
+		SRGB_APPROX(specular_brdf_NL)
+		specular_light += specular_brdf_NL * light_color * specular_blob_intensity * attenuation;
+
+
+#if defined(LIGHT_USE_CLEARCOAT)
+		if (clearcoat_gloss > 0.0) {
+#if !defined(SPECULAR_SCHLICK_GGX) && !defined(SPECULAR_BLINN)
+			vec3 H = normalize(V + L);
+#endif
+#if !defined(SPECULAR_SCHLICK_GGX)
+			float cNdotH = max(dot(N, H), 0.0);
+			float cLdotH = max(dot(L, H), 0.0);
+			float cLdotH5 = SchlickFresnel(cLdotH);
+#endif
+			float Dr = GTR1(cNdotH, mix(.1, .001, clearcoat_gloss));
+			float Fr = mix(.04, 1.0, cLdotH5);
+			float Gr = G_GGX_2cos(cNdotL, .25) * G_GGX_2cos(cNdotV, .25);
+
+			float specular_brdf_NL = 0.25 * clearcoat * Gr * Fr * Dr * cNdotL;
+
+			specular_light += specular_brdf_NL * light_color * specular_blob_intensity * attenuation;
+		}
+#endif
 	}
+
+
+#endif //defined(USE_LIGHT_SHADER_CODE)
+
 }
 
+#endif
 // shadows
 
+#ifdef USE_SHADOW
+
+#define SAMPLE_SHADOW_TEXEL(p_shadow,p_pos,p_depth) step(p_depth,texture2D(p_shadow,p_pos).r)
+
 float sample_shadow(
 		highp sampler2D shadow,
-		vec2 shadow_pixel_size,
-		vec2 pos,
-		float depth,
-		vec4 clamp_rect) {
-	// vec4 depth_value = texture2D(shadow, pos);
-
-	// return depth_value.z;
-	return texture2DProj(shadow, vec4(pos, depth, 1.0)).r;
-	// return (depth_value.x + depth_value.y + depth_value.z + depth_value.w) / 4.0;
+		highp vec2 pos,
+		highp float depth) {
+
+
+#ifdef SHADOW_MODE_PCF_13
+
+	float avg = SAMPLE_SHADOW_TEXEL(shadow, pos, depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, -shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x * 2.0, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x * 2.0, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y * 2.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y * 2.0), depth);
+	return avg * (1.0 / 13.0);
+#endif
+
+#ifdef SHADOW_MODE_PCF_5
+
+	float avg = SAMPLE_SHADOW_TEXEL(shadow, pos, depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(-shadow_pixel_size.x, 0.0), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, shadow_pixel_size.y), depth);
+	avg += SAMPLE_SHADOW_TEXEL(shadow, pos + vec2(0.0, -shadow_pixel_size.y), depth);
+	return avg * (1.0 / 5.0);
+
+#endif
+
+#if !defined(SHADOW_MODE_PCF_5) || !defined(SHADOW_MODE_PCF_13)
+
+	return SAMPLE_SHADOW_TEXEL(shadow, pos, depth);
+#endif
+
 }
 
 #endif
 
 void main() {
 
+#ifdef RENDER_DEPTH_DUAL_PARABOLOID
+
+	if (dp_clip > 0.0)
+		discard;
+#endif
 	highp vec3 vertex = vertex_interp;
 	vec3 albedo = vec3(1.0);
 	vec3 transmission = vec3(0.0);
@@ -540,11 +1105,8 @@ FRAGMENT_SHADER_CODE
 
 	vec3 specular_light = vec3(0.0, 0.0, 0.0);
 	vec3 diffuse_light = vec3(0.0, 0.0, 0.0);
-
 	vec3 ambient_light = vec3(0.0, 0.0, 0.0);
 
-	vec3 env_reflection_light = vec3(0.0, 0.0, 0.0);
-
 	vec3 eye_position = -normalize(vertex_interp);
 
 #ifdef ALPHA_SCISSOR_USED
@@ -553,287 +1115,293 @@ FRAGMENT_SHADER_CODE
 	}
 #endif
 
+#ifdef BASE_PASS
+	//none
+#ifdef USE_RADIANCE_MAP
+
+	vec3 ref_vec = reflect(-eye_position, N);
+	ref_vec = normalize((radiance_inverse_xform * vec4(ref_vec, 0.0)).xyz);
+
+	ref_vec.z *= -1.0;
+
+	specular_light = textureCubeLod(radiance_map, ref_vec, roughness * RADIANCE_MAX_LOD).xyz * bg_energy;
+
+	{
+		vec3 ambient_dir = normalize((radiance_inverse_xform * vec4(normal, 0.0)).xyz);
+		vec3 env_ambient = textureCubeLod(radiance_map, ambient_dir, RADIANCE_MAX_LOD).xyz * bg_energy;
+
+		ambient_light = mix(ambient_color.rgb, env_ambient, ambient_sky_contribution);
+	}
+
+#else
+
+	ambient_light = ambient_color.rgb;
+
+#endif
+
+	ambient_light *= ambient_energy;
+
+#endif //BASE PASS
+
 //
 // Lighting
 //
-#ifdef LIGHT_PASS
-
-	if (light_type == LIGHT_TYPE_OMNI) {
-		vec3 light_vec = light_position - vertex;
-		float light_length = length(light_vec);
+#ifdef USE_LIGHTING
 
-		float normalized_distance = light_length / light_range;
+#ifndef USE_VERTEX_LIGHTING
+	vec3 L;
+#endif
+	vec3 light_att=vec3(1.0);
 
-		float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
+#ifdef LIGHT_MODE_OMNI
 
-		vec3 attenuation = vec3(omni_attenuation);
+#ifndef USE_VERTEX_LIGHTING
+	vec3 light_vec = light_position - vertex;
+	float light_length = length(light_vec);
 
-		if (light_has_shadow > 0.5) {
-			highp vec3 splane = (light_shadow_matrix * vec4(vertex, 1.0)).xyz;
-			float shadow_len = length(splane);
+	float normalized_distance = light_length / light_range;
 
-			splane = normalize(splane);
+	float omni_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
 
-			vec4 clamp_rect = light_clamp;
+	light_att=vec3(omni_attenuation);
+	L = normalize(light_vec);
 
-			if (splane.z >= 0.0) {
-				splane.z += 1.0;
+#endif
 
-				clamp_rect.y += clamp_rect.w;
-			} else {
-				splane.z = 1.0 - splane.z;
-			}
+#ifdef USE_SHADOW
+	{
+		highp vec3 splane = shadow_coord.xyz;
+		float shadow_len = length(splane);
 
-			splane.xy /= splane.z;
-			splane.xy = splane.xy * 0.5 + 0.5;
-			splane.z = shadow_len / light_range;
+		splane = normalize(splane);
 
-			splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
+		vec4 clamp_rect = light_clamp;
 
-			float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), splane.xy, splane.z, clamp_rect);
+		if (splane.z >= 0.0) {
+			splane.z += 1.0;
 
-			if (shadow > splane.z) {
-			} else {
-				attenuation = vec3(0.0);
-			}
+			clamp_rect.y += clamp_rect.w;
+		} else {
+			splane.z = 1.0 - splane.z;
 		}
 
-		light_compute(
-				normal,
-				normalize(light_vec),
-				eye_position,
-				binormal,
-				tangent,
-				light_color.xyz * light_energy,
-				attenuation,
-				albedo,
-				transmission,
-				specular * light_specular,
-				roughness,
-				metallic,
-				rim,
-				rim_tint,
-				clearcoat,
-				clearcoat_gloss,
-				anisotropy,
-				diffuse_light,
-				specular_light);
-
-	} else if (light_type == LIGHT_TYPE_DIRECTIONAL) {
-
-		vec3 light_vec = -light_direction;
-		vec3 attenuation = vec3(1.0, 1.0, 1.0);
-
-		float depth_z = -vertex.z;
-
-		if (light_has_shadow > 0.5) {
+		splane.xy /= splane.z;
+		splane.xy = splane.xy * 0.5 + 0.5;
+		splane.z = shadow_len / light_range;
+
+		splane.xy = clamp_rect.xy + splane.xy * clamp_rect.zw;
+
+		float shadow = sample_shadow(light_shadow_atlas, splane.xy, splane.z);
+
+		light_att*=shadow;
+
+	}
+#endif
+
+#endif //type omni
+
+#ifdef LIGHT_MODE_DIRECTIONAL
 
+#ifndef USE_VERTEX_LIGHTING
+	vec3 light_vec = -light_direction;
+	L = normalize(light_vec);
+#endif
+	float depth_z = -vertex.z;
+
+#ifdef USE_SHADOW
+	{
 #ifdef LIGHT_USE_PSSM4
-			if (depth_z < light_split_offsets.w) {
+		if (depth_z < light_split_offsets.w) {
 #elif defined(LIGHT_USE_PSSM2)
-			if (depth_z < light_split_offsets.y) {
+		if (depth_z < light_split_offsets.y) {
 #else
-			if (depth_z < light_split_offsets.x) {
-#endif
+		if (depth_z < light_split_offsets.x) {
+#endif //pssm2
 
-				vec3 pssm_coord;
-				float pssm_fade = 0.0;
+			vec3 pssm_coord;
+			float pssm_fade = 0.0;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-				float pssm_blend;
-				vec3 pssm_coord2;
-				bool use_blend = true;
+			float pssm_blend;
+			vec3 pssm_coord2;
+			bool use_blend = true;
 #endif
 
 #ifdef LIGHT_USE_PSSM4
-				if (depth_z < light_split_offsets.y) {
-					if (depth_z < light_split_offsets.x) {
-						highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-						pssm_coord = splane.xyz / splane.w;
+			if (depth_z < light_split_offsets.y) {
+				if (depth_z < light_split_offsets.x) {
+					highp vec4 splane = shadow_coord;
+					pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-						splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-						pssm_coord2 = splane.xyz / splane.w;
+					splane = shadow_coord2;
+					pssm_coord2 = splane.xyz / splane.w;
 
-						pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+					pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
 #endif
-					} else {
-						highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-						pssm_coord = splane.xyz / splane.w;
+				} else {
+					highp vec4 splane = shadow_coord2;
+					pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-						splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
-						pssm_coord2 = splane.xyz / splane.w;
+					splane = shadow_coord3;
+					pssm_coord2 = splane.xyz / splane.w;
 
-						pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+					pssm_blend = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
 #endif
-					}
-				} else {
-					if (depth_z < light_split_offsets.z) {
+				}
+			} else {
+				if (depth_z < light_split_offsets.z) {
 
-						highp vec4 splane = (light_shadow_matrix3 * vec4(vertex, 1.0));
-						pssm_coord = splane.xyz / splane.w;
+					highp vec4 splane = shadow_coord3;
+					pssm_coord = splane.xyz / splane.w;
 
 #if defined(LIGHT_USE_PSSM_BLEND)
-						splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
-						pssm_coord2 = splane.xyz / splane.w;
-						pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
+					splane = shadow_coord4;
+					pssm_coord2 = splane.xyz / splane.w;
+					pssm_blend = smoothstep(light_split_offsets.y, light_split_offsets.z, depth_z);
 #endif
 
-					} else {
+				} else {
 
-						highp vec4 splane = (light_shadow_matrix4 * vec4(vertex, 1.0));
-						pssm_coord = splane.xyz / splane.w;
-						pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
+					highp vec4 splane = shadow_coord4;
+					pssm_coord = splane.xyz / splane.w;
+					pssm_fade = smoothstep(light_split_offsets.z, light_split_offsets.w, depth_z);
 
 #if defined(LIGHT_USE_PSSM_BLEND)
-						use_blend = false;
+					use_blend = false;
 #endif
-					}
 				}
+			}
 
 #endif // LIGHT_USE_PSSM4
 
 #ifdef LIGHT_USE_PSSM2
-				if (depth_z < light_split_offsets.x) {
+			if (depth_z < light_split_offsets.x) {
 
-					highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
+				highp vec4 splane = shadow_coord;
+				pssm_coord = splane.xyz / splane.w;
 
 #ifdef LIGHT_USE_PSSM_BLEND
-					splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-					pssm_coord2 = splane.xyz / splane.w;
-					pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
+				splane = shadow_coord2;
+				pssm_coord2 = splane.xyz / splane.w;
+				pssm_blend = smoothstep(0.0, light_split_offsets.x, depth_z);
 #endif
-				} else {
-					highp vec4 splane = (light_shadow_matrix2 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
-					pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
+			} else {
+				highp vec4 splane = shadow_coord2;
+				pssm_coord = splane.xyz / splane.w;
+				pssm_fade = smoothstep(light_split_offsets.x, light_split_offsets.y, depth_z);
 #ifdef LIGHT_USE_PSSM_BLEND
-					use_blend = false;
+				use_blend = false;
 #endif
-				}
+			}
 
 #endif // LIGHT_USE_PSSM2
 
 #if !defined(LIGHT_USE_PSSM4) && !defined(LIGHT_USE_PSSM2)
-				{
-					highp vec4 splane = (light_shadow_matrix1 * vec4(vertex, 1.0));
-					pssm_coord = splane.xyz / splane.w;
-				}
+			{
+				highp vec4 splane = shadow_coord;
+				pssm_coord = splane.xyz / splane.w;
+			}
 #endif
 
-				float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord.xy, pssm_coord.z, light_clamp);
+			float shadow = sample_shadow(light_directional_shadow, pssm_coord.xy, pssm_coord.z);
 
 #ifdef LIGHT_USE_PSSM_BLEND
-				if (use_blend) {
-					shadow = mix(shadow, sample_shadow(light_shadow_atlas, vec2(0.0), pssm_coord2.xy, pssm_coord2.z, light_clamp), pssm_blend);
-				}
+			if (use_blend) {
+				shadow = mix(shadow, sample_shadow(light_directional_shadow, pssm_coord2.xy, pssm_coord2.z), pssm_blend);
+			}
 #endif
 
-				attenuation *= shadow;
-			}
+			light_att *= shadow;
 		}
+	}
+#endif //use shadow
 
-		light_compute(normal,
-				normalize(light_vec),
-				eye_position,
-				binormal,
-				tangent,
-				light_color.xyz * light_energy,
-				attenuation,
-				albedo,
-				transmission,
-				specular * light_specular,
-				roughness,
-				metallic,
-				rim,
-				rim_tint,
-				clearcoat,
-				clearcoat_gloss,
-				anisotropy,
-				diffuse_light,
-				specular_light);
-	} else if (light_type == LIGHT_TYPE_SPOT) {
-
-		vec3 light_att = vec3(1.0);
-
-		if (light_has_shadow > 0.5) {
-			highp vec4 splane = (light_shadow_matrix * vec4(vertex, 1.0));
-			splane.xyz /= splane.w;
-
-			float shadow = sample_shadow(light_shadow_atlas, vec2(0.0), splane.xy, splane.z, light_clamp);
-
-			if (shadow > splane.z) {
-			} else {
-				light_att = vec3(0.0);
-			}
-		}
 
-		vec3 light_rel_vec = light_position - vertex;
-		float light_length = length(light_rel_vec);
-		float normalized_distance = light_length / light_range;
-
-		float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
-		vec3 spot_dir = light_direction;
-
-		float spot_cutoff = light_spot_angle;
-
-		float scos = max(dot(-normalize(light_rel_vec), spot_dir), spot_cutoff);
-		float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));
-
-		spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);
-
-		light_att *= vec3(spot_attenuation);
-
-		light_compute(
-				normal,
-				normalize(light_rel_vec),
-				eye_position,
-				binormal,
-				tangent,
-				light_color.xyz * light_energy,
-				light_att,
-				albedo,
-				transmission,
-				specular * light_specular,
-				roughness,
-				metallic,
-				rim,
-				rim_tint,
-				clearcoat,
-				clearcoat_gloss,
-				anisotropy,
-				diffuse_light,
-				specular_light);
-	}
+#endif
 
-	gl_FragColor = vec4(ambient_light + diffuse_light + specular_light, alpha);
-#else
+#ifdef LIGHT_MODE_SPOT
 
-#ifdef RENDER_DEPTH
 
-#else
+	light_att = vec3(1.0);
 
-#ifdef USE_RADIANCE_MAP
+#ifndef USE_VERTEX_LIGHTING
 
-	vec3 ref_vec = reflect(-eye_position, N);
-	ref_vec = normalize((radiance_inverse_xform * vec4(ref_vec, 0.0)).xyz);
+	vec3 light_rel_vec = light_position - vertex;
+	float light_length = length(light_rel_vec);
+	float normalized_distance = light_length / light_range;
 
-	ref_vec.z *= -1.0;
+	float spot_attenuation = pow(1.0 - normalized_distance, light_attenuation.w);
+	vec3 spot_dir = light_direction;
+
+	float spot_cutoff = light_spot_angle;
+
+	float scos = max(dot(-normalize(light_rel_vec), spot_dir), spot_cutoff);
+	float spot_rim = max(0.0001, (1.0 - scos) / (1.0 - spot_cutoff));
+
+	spot_attenuation *= 1.0 - pow(spot_rim, light_spot_attenuation);
 
-	env_reflection_light = textureCubeLod(radiance_map, ref_vec, roughness * RADIANCE_MAX_LOD).xyz * bg_energy;
+	light_att = vec3(spot_attenuation);
 
+	L = normalize(light_rel_vec);
+
+#endif
+
+#ifdef USE_SHADOW
 	{
-		vec3 ambient_dir = normalize((radiance_inverse_xform * vec4(normal, 0.0)).xyz);
-		vec3 env_ambient = textureCubeLod(radiance_map, ambient_dir, RADIANCE_MAX_LOD).xyz * bg_energy;
+		highp vec4 splane = shadow_coord;
+		splane.xyz /= splane.w;
 
-		ambient_light = mix(ambient_color.rgb, env_ambient, ambient_sky_contribution);
+		float shadow = sample_shadow(light_shadow_atlas, splane.xy, splane.z);
+		light_att *= shadow;
 	}
+#endif
 
-	ambient_light *= ambient_energy;
 
-	specular_light += env_reflection_light;
+
+#endif
+
+#ifdef USE_VERTEX_LIGHTING
+//vertex lighting
+
+	specular_light += specular_interp * specular * light_att;
+	diffuse_light += diffuse_interp * albedo * light_att;
+
+#else
+//fragment lighting
+	light_compute(
+			normal,
+			L,
+			eye_position,
+			binormal,
+			tangent,
+			light_color.xyz,
+			light_att,
+			albedo,
+			transmission,
+			specular * light_specular,
+			roughness,
+			metallic,
+			rim,
+			rim_tint,
+			clearcoat,
+			clearcoat_gloss,
+			anisotropy,
+			diffuse_light,
+			specular_light);
+
+#endif //vertex lighting
+
+#endif //USE_LIGHTING
+//compute and merge
+
+#ifndef RENDER_DEPTH
+
+#ifdef SHADELESS
+
+	gl_FragColor = vec4(albedo, alpha);
+#else
 
 	ambient_light *= albedo;
 
@@ -865,10 +1433,9 @@ FRAGMENT_SHADER_CODE
 	gl_FragColor = vec4(ambient_light + diffuse_light + specular_light, alpha);
 	// gl_FragColor = vec4(normal, 1.0);
 
-#else
-	gl_FragColor = vec4(albedo, alpha);
-#endif
-#endif // RENDER_DEPTH
+#endif //unshaded
+
+
+#endif // not RENDER_DEPTH
 
-#endif // lighting
 }
diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp
index 1e43651d54..086829f9ba 100644
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -1557,8 +1557,11 @@ void RasterizerSceneGLES3::_render_geometry(RenderList::Element *e) {
 			RasterizerStorageGLES3::MultiMesh *multi_mesh = static_cast<RasterizerStorageGLES3::MultiMesh *>(e->owner);
 			RasterizerStorageGLES3::Surface *s = static_cast<RasterizerStorageGLES3::Surface *>(e->geometry);
 
-			int amount = MAX(multi_mesh->size, multi_mesh->visible_instances);
+			int amount = MIN(multi_mesh->size, multi_mesh->visible_instances);
 
+			if (amount == -1) {
+				amount = multi_mesh->size;
+			}
 #ifdef DEBUG_ENABLED
 
 			if (state.debug_draw == VS::VIEWPORT_DEBUG_DRAW_WIREFRAME && s->array_wireframe_id) {
@@ -2364,14 +2367,15 @@ void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::G
 	e->sort_key |= uint64_t(e->geometry->index) << RenderList::SORT_KEY_GEOMETRY_INDEX_SHIFT;
 	e->sort_key |= uint64_t(e->instance->base_type) << RenderList::SORT_KEY_GEOMETRY_TYPE_SHIFT;
 
-	if (!p_depth_pass) {
+	if (e->material->last_pass != render_pass) {
+		e->material->last_pass = render_pass;
+		e->material->index = current_material_index++;
+	}
 
-		if (e->material->last_pass != render_pass) {
-			e->material->last_pass = render_pass;
-			e->material->index = current_material_index++;
-		}
+	e->sort_key |= uint64_t(e->material->index) << RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
+	e->sort_key |= uint64_t(e->instance->depth_layer) << RenderList::SORT_KEY_OPAQUE_DEPTH_LAYER_SHIFT;
 
-		e->sort_key |= uint64_t(e->material->index) << RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
+	if (!p_depth_pass) {
 
 		if (e->instance->gi_probe_instances.size()) {
 			e->sort_key |= SORT_KEY_GI_PROBES_FLAG;
@@ -2386,9 +2390,6 @@ void RasterizerSceneGLES3::_add_geometry_with_material(RasterizerStorageGLES3::G
 		}
 
 		e->sort_key |= uint64_t(p_material->render_priority + 128) << RenderList::SORT_KEY_PRIORITY_SHIFT;
-	} else {
-		e->sort_key |= uint64_t(e->instance->depth_layer) << RenderList::SORT_KEY_OPAQUE_DEPTH_LAYER_SHIFT;
-		e->sort_key |= uint64_t(e->material->index) << RenderList::SORT_KEY_MATERIAL_INDEX_SHIFT;
 	}
 
 	/*
@@ -2738,7 +2739,7 @@ void RasterizerSceneGLES3::_setup_directional_light(int p_index, const Transform
 
 			ubo_data.shadow_split_offsets[j] = li->shadow_transform[j].split;
 
-			Transform modelview = (p_camera_inverse_transform * li->shadow_transform[j].transform).inverse();
+			Transform modelview = (p_camera_inverse_transform * li->shadow_transform[j].transform).affine_inverse();
 
 			CameraMatrix bias;
 			bias.set_light_bias();
@@ -3131,7 +3132,6 @@ void RasterizerSceneGLES3::_fill_render_list(InstanceBase **p_cull_result, int p
 	current_material_index = 0;
 	state.used_sss = false;
 	state.used_screen_texture = false;
-
 	//fill list
 
 	for (int i = 0; i < p_cull_count; i++) {
@@ -5147,13 +5147,13 @@ void RasterizerSceneGLES3::initialize() {
 
 void RasterizerSceneGLES3::iteration() {
 
-	shadow_filter_mode = ShadowFilterMode(int(ProjectSettings::get_singleton()->get("rendering/quality/shadows/filter_mode")));
-	subsurface_scatter_follow_surface = ProjectSettings::get_singleton()->get("rendering/quality/subsurface_scattering/follow_surface");
-	subsurface_scatter_weight_samples = ProjectSettings::get_singleton()->get("rendering/quality/subsurface_scattering/weight_samples");
-	subsurface_scatter_quality = SubSurfaceScatterQuality(int(ProjectSettings::get_singleton()->get("rendering/quality/subsurface_scattering/quality")));
-	subsurface_scatter_size = ProjectSettings::get_singleton()->get("rendering/quality/subsurface_scattering/scale");
+	shadow_filter_mode = ShadowFilterMode(int(GLOBAL_GET("rendering/quality/shadows/filter_mode")));
+	subsurface_scatter_follow_surface = GLOBAL_GET("rendering/quality/subsurface_scattering/follow_surface");
+	subsurface_scatter_weight_samples = GLOBAL_GET("rendering/quality/subsurface_scattering/weight_samples");
+	subsurface_scatter_quality = SubSurfaceScatterQuality(int(GLOBAL_GET("rendering/quality/subsurface_scattering/quality")));
+	subsurface_scatter_size = GLOBAL_GET("rendering/quality/subsurface_scattering/scale");
 
-	state.scene_shader.set_conditional(SceneShaderGLES3::VCT_QUALITY_HIGH, ProjectSettings::get_singleton()->get("rendering/quality/voxel_cone_tracing/high_quality"));
+	state.scene_shader.set_conditional(SceneShaderGLES3::VCT_QUALITY_HIGH, GLOBAL_GET("rendering/quality/voxel_cone_tracing/high_quality"));
 }
 
 void RasterizerSceneGLES3::finalize() {
diff --git a/drivers/gles3/shader_compiler_gles3.cpp b/drivers/gles3/shader_compiler_gles3.cpp
index 11c84e7db8..350107de69 100644
--- a/drivers/gles3/shader_compiler_gles3.cpp
+++ b/drivers/gles3/shader_compiler_gles3.cpp
@@ -31,6 +31,7 @@
 #include "shader_compiler_gles3.h"
 
 #include "core/os/os.h"
+#include "core/project_settings.h"
 
 #define SL ShaderLanguage
 
@@ -860,6 +861,7 @@ ShaderCompilerGLES3::ShaderCompilerGLES3() {
 	actions[VS::SHADER_SPATIAL].renames["SCREEN_TEXTURE"] = "screen_texture";
 	actions[VS::SHADER_SPATIAL].renames["DEPTH_TEXTURE"] = "depth_buffer";
 	actions[VS::SHADER_SPATIAL].renames["ALPHA_SCISSOR"] = "alpha_scissor";
+	actions[VS::SHADER_SPATIAL].renames["OUTPUT_IS_SRGB"] = "SHADER_IS_SRGB";
 
 	//for light
 	actions[VS::SHADER_SPATIAL].renames["VIEW"] = "view";
@@ -901,12 +903,24 @@ ShaderCompilerGLES3::ShaderCompilerGLES3() {
 	actions[VS::SHADER_SPATIAL].render_mode_defines["cull_front"] = "#define DO_SIDE_CHECK\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["cull_disabled"] = "#define DO_SIDE_CHECK\n";
 
-	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
+	bool force_lambert = GLOBAL_GET("rendering/quality/shading/force_lambert_over_burley");
+
+	if (!force_lambert) {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_burley"] = "#define DIFFUSE_BURLEY\n";
+	}
+
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_oren_nayar"] = "#define DIFFUSE_OREN_NAYAR\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_lambert_wrap"] = "#define DIFFUSE_LAMBERT_WRAP\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["diffuse_toon"] = "#define DIFFUSE_TOON\n";
 
-	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
+	bool force_blinn = GLOBAL_GET("rendering/quality/shading/force_blinn_over_ggx");
+
+	if (!force_blinn) {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_SCHLICK_GGX\n";
+	} else {
+		actions[VS::SHADER_SPATIAL].render_mode_defines["specular_schlick_ggx"] = "#define SPECULAR_BLINN\n";
+	}
+
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_blinn"] = "#define SPECULAR_BLINN\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_phong"] = "#define SPECULAR_PHONG\n";
 	actions[VS::SHADER_SPATIAL].render_mode_defines["specular_toon"] = "#define SPECULAR_TOON\n";
diff --git a/drivers/gles3/shader_gles3.cpp b/drivers/gles3/shader_gles3.cpp
index 2a3b8a9b91..799179e8d4 100644
--- a/drivers/gles3/shader_gles3.cpp
+++ b/drivers/gles3/shader_gles3.cpp
@@ -122,6 +122,11 @@ bool ShaderGLES3::bind() {
 
 	ERR_FAIL_COND_V(!version, false);
 
+	if (!version->ok) { //broken, unable to bind (do not throw error, you saw it before already when it failed compilation).
+		glUseProgram(0);
+		return false;
+	}
+
 	glUseProgram(version->id);
 
 	DEBUG_TEST_ERROR("Use Program");
diff --git a/drivers/gles3/shader_gles3.h b/drivers/gles3/shader_gles3.h
index ca74317218..9db4942163 100644
--- a/drivers/gles3/shader_gles3.h
+++ b/drivers/gles3/shader_gles3.h
@@ -336,6 +336,7 @@ public:
 	}
 
 	uint32_t get_version() const { return new_conditional_version.version; }
+	_FORCE_INLINE_ bool is_version_valid() const { return version && version->ok; }
 
 	void set_uniform_camera(int p_idx, const CameraMatrix &p_mat) {
 
diff --git a/drivers/gles3/shaders/scene.glsl b/drivers/gles3/shaders/scene.glsl
index 12cbe02d0c..49296b7f4a 100644
--- a/drivers/gles3/shaders/scene.glsl
+++ b/drivers/gles3/shaders/scene.glsl
@@ -3,6 +3,8 @@
 
 #define M_PI 3.14159265359
 
+#define SHADER_IS_SRGB false
+
 /*
 from VisualServer:
 
@@ -514,6 +516,7 @@ VERTEX_SHADER_CODE
 /* clang-format off */
 [fragment]
 
+
 /* texture unit usage, N is max_texture_unity-N
 
 1-skeleton
@@ -533,6 +536,7 @@ uniform highp mat4 world_transform;
 /* clang-format on */
 
 #define M_PI 3.14159265359
+#define SHADER_IS_SRGB false
 
 /* Varyings */
 
@@ -1020,18 +1024,30 @@ LIGHT_SHADER_CODE
 
 #if defined(SPECULAR_BLINN)
 
+		//normalized blinn
 		vec3 H = normalize(V + L);
 		float cNdotH = max(dot(N, H), 0.0);
-		float intensity = pow(cNdotH, (1.0 - roughness) * 256.0);
+		float cVdotH = max(dot(V, H), 0.0);
+		float cLdotH = max(dot(L, H), 0.0);
+		float shininess = exp2( 15.0 * (1.0 - roughness) + 1.0 ) * 0.25;
+		float blinn = pow( cNdotH, shininess );
+		blinn *= (shininess + 8.0) / (8.0 * 3.141592654);
+		float intensity = ( blinn ) / max( 4.0 * cNdotV * cNdotL, 0.75 );
+
 		specular_light += light_color * intensity * specular_blob_intensity * attenuation;
 
 #elif defined(SPECULAR_PHONG)
 
 		vec3 R = normalize(-reflect(L, N));
 		float cRdotV = max(0.0, dot(R, V));
-		float intensity = pow(cRdotV, (1.0 - roughness) * 256.0);
+		float shininess = exp2( 15.0 * (1.0 - roughness) + 1.0 ) * 0.25;
+		float phong = pow( cRdotV, shininess );
+		phong *= (shininess + 8.0) / (8.0 * 3.141592654);
+		float intensity = ( phong ) / max( 4.0 * cNdotV * cNdotL, 0.75 );
+
 		specular_light += light_color * intensity * specular_blob_intensity * attenuation;
 
+
 #elif defined(SPECULAR_TOON)
 
 		vec3 R = normalize(-reflect(L, N));
@@ -1070,11 +1086,11 @@ LIGHT_SHADER_CODE
 		float G = G_GGX_2cos(cNdotL, alpha) * G_GGX_2cos(cNdotV, alpha);
 #endif
 		// F
-		float F0 = 1.0; // FIXME
-		float cLdotH5 = SchlickFresnel(cLdotH);
-		float F = mix(cLdotH5, 1.0, F0);
+		//float F0 = 1.0;
+		//float cLdotH5 = SchlickFresnel(cLdotH);
+		//float F = mix(cLdotH5, 1.0, F0);
 
-		float specular_brdf_NL = cNdotL * D * F * G;
+		float specular_brdf_NL = cNdotL * D /* F */ * G;
 
 		specular_light += specular_brdf_NL * light_color * specular_blob_intensity * attenuation;
 #endif