Basic 3D rendering

22 files changed, 1728 insertions, 253 deletions

diff --git a/drivers/gles3/rasterizer_canvas_gles3.cpp b/drivers/gles3/rasterizer_canvas_gles3.cpp
index 1197f4aac1..df54686574 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.cpp
+++ b/drivers/gles3/rasterizer_canvas_gles3.cpp
@@ -179,12 +179,12 @@ void RasterizerCanvasGLES3::canvas_render_items(RID p_to_render_target, Item *p_
 
 		//print_line("w: " + itos(ssize.width) + " s: " + rtos(canvas_scale));
 		state_buffer.tex_to_sdf = 1.0 / ((canvas_scale.x + canvas_scale.y) * 0.5);
-		glBindBufferBase(GL_UNIFORM_BUFFER, BASE_UNIFORM_BUFFER_OBJECT, state.canvas_state_buffer);
+		glBindBufferBase(GL_UNIFORM_BUFFER, BASE_UNIFORM_LOCATION, state.canvas_state_buffer);
 		glBufferData(GL_UNIFORM_BUFFER, sizeof(StateBuffer), &state_buffer, GL_STREAM_DRAW);
 
 		GLuint global_buffer = material_storage->global_variables_get_uniform_buffer();
 
-		glBindBufferBase(GL_UNIFORM_BUFFER, GLOBAL_UNIFORM_BUFFER_OBJECT, global_buffer);
+		glBindBufferBase(GL_UNIFORM_BUFFER, GLOBAL_UNIFORM_LOCATION, global_buffer);
 		glBindBuffer(GL_UNIFORM_BUFFER, 0);
 	}
 
@@ -522,7 +522,7 @@ void RasterizerCanvasGLES3::_render_item(RID p_render_target, const Item *p_item
 					}
 				}
 
-				glBindBufferBase(GL_UNIFORM_BUFFER, INSTANCE_UNIFORM_BUFFER_OBJECT, state.canvas_instance_data_buffers[state.current_buffer]);
+				glBindBufferBase(GL_UNIFORM_BUFFER, INSTANCE_UNIFORM_LOCATION, state.canvas_instance_data_buffers[state.current_buffer]);
 #ifdef JAVASCRIPT_ENABLED
 				//WebGL 2.0 does not support mapping buffers, so use slow glBufferData instead
 				glBufferData(GL_UNIFORM_BUFFER, sizeof(InstanceData), &state.instance_data_array[0], GL_DYNAMIC_DRAW);
@@ -728,7 +728,7 @@ void RasterizerCanvasGLES3::_render_batch(uint32_t &r_index) {
 			}
 		}
 
-		glBindBufferBase(GL_UNIFORM_BUFFER, INSTANCE_UNIFORM_BUFFER_OBJECT, state.canvas_instance_data_buffers[state.current_buffer]);
+		glBindBufferBase(GL_UNIFORM_BUFFER, INSTANCE_UNIFORM_LOCATION, state.canvas_instance_data_buffers[state.current_buffer]);
 #ifdef JAVASCRIPT_ENABLED
 		//WebGL 2.0 does not support mapping buffers, so use slow glBufferData instead
 		glBufferData(GL_UNIFORM_BUFFER, sizeof(InstanceData) * r_index, state.instance_data_array, GL_DYNAMIC_DRAW);
diff --git a/drivers/gles3/rasterizer_canvas_gles3.h b/drivers/gles3/rasterizer_canvas_gles3.h
index b77b295de9..aedde7c265 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.h
+++ b/drivers/gles3/rasterizer_canvas_gles3.h
@@ -97,13 +97,12 @@ class RasterizerCanvasGLES3 : public RendererCanvasRender {
 	};
 
 public:
-	//TODO move to Material storage
 	enum {
-		BASE_UNIFORM_BUFFER_OBJECT = 0,
-		GLOBAL_UNIFORM_BUFFER_OBJECT = 1,
-		LIGHT_UNIFORM_BUFFER_OBJECT = 2,
-		INSTANCE_UNIFORM_BUFFER_OBJECT = 3,
-		MATERIAL_UNIFORM_BUFFER_OBJECT = 4,
+		BASE_UNIFORM_LOCATION = 0,
+		GLOBAL_UNIFORM_LOCATION = 1,
+		LIGHT_UNIFORM_LOCATION = 2,
+		INSTANCE_UNIFORM_LOCATION = 3,
+		MATERIAL_UNIFORM_LOCATION = 4,
 	};
 
 	struct StateBuffer {
diff --git a/drivers/gles3/rasterizer_gles3.cpp b/drivers/gles3/rasterizer_gles3.cpp
index e09355e433..787c4b8c49 100644
--- a/drivers/gles3/rasterizer_gles3.cpp
+++ b/drivers/gles3/rasterizer_gles3.cpp
@@ -268,10 +268,6 @@ RasterizerGLES3::RasterizerGLES3() {
 	storage = memnew(RasterizerStorageGLES3);
 	canvas = memnew(RasterizerCanvasGLES3(storage));
 	scene = memnew(RasterizerSceneGLES3(storage));
-
-	texture_storage->set_main_thread_id(Thread::get_caller_id());
-	// make sure the OS knows to only access the renderer from the main thread
-	OS::get_singleton()->set_render_main_thread_mode(OS::RENDER_MAIN_THREAD_ONLY);
 }
 
 RasterizerGLES3::~RasterizerGLES3() {
diff --git a/drivers/gles3/rasterizer_scene_gles3.cpp b/drivers/gles3/rasterizer_scene_gles3.cpp
index cabb06d837..68657b9152 100644
--- a/drivers/gles3/rasterizer_scene_gles3.cpp
+++ b/drivers/gles3/rasterizer_scene_gles3.cpp
@@ -31,6 +31,7 @@
 #include "rasterizer_scene_gles3.h"
 #include "core/config/project_settings.h"
 #include "servers/rendering/rendering_server_default.h"
+#include "storage/config.h"
 
 #ifdef GLES3_ENABLED
 
@@ -42,66 +43,169 @@ RasterizerSceneGLES3 *RasterizerSceneGLES3::get_singleton() {
 	return singleton;
 }
 
-RasterizerSceneGLES3::GeometryInstance *RasterizerSceneGLES3::geometry_instance_create(RID p_base) {
-	return nullptr;
+RendererSceneRender::GeometryInstance *RasterizerSceneGLES3::geometry_instance_create(RID p_base) {
+	RS::InstanceType type = storage->get_base_type(p_base);
+	ERR_FAIL_COND_V(!((1 << type) & RS::INSTANCE_GEOMETRY_MASK), nullptr);
+
+	GeometryInstanceGLES3 *ginstance = geometry_instance_alloc.alloc();
+	ginstance->data = memnew(GeometryInstanceGLES3::Data);
+
+	ginstance->data->base = p_base;
+	ginstance->data->base_type = type;
+
+	_geometry_instance_mark_dirty(ginstance);
+
+	return ginstance;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_skeleton(GeometryInstance *p_geometry_instance, RID p_skeleton) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->skeleton = p_skeleton;
+
+	_geometry_instance_mark_dirty(ginstance);
+	ginstance->data->dirty_dependencies = true;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_material_override(GeometryInstance *p_geometry_instance, RID p_override) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->material_override = p_override;
+
+	_geometry_instance_mark_dirty(ginstance);
+	ginstance->data->dirty_dependencies = true;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_material_overlay(GeometryInstance *p_geometry_instance, RID p_overlay) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->material_overlay = p_overlay;
+
+	_geometry_instance_mark_dirty(ginstance);
+	ginstance->data->dirty_dependencies = true;
 }
 
-void RasterizerSceneGLES3::geometry_instance_set_surface_materials(GeometryInstance *p_geometry_instance, const Vector<RID> &p_material) {
+void RasterizerSceneGLES3::geometry_instance_set_surface_materials(GeometryInstance *p_geometry_instance, const Vector<RID> &p_materials) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->surface_materials = p_materials;
+
+	_geometry_instance_mark_dirty(ginstance);
+	ginstance->data->dirty_dependencies = true;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_mesh_instance(GeometryInstance *p_geometry_instance, RID p_mesh_instance) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->mesh_instance = p_mesh_instance;
+
+	_geometry_instance_mark_dirty(ginstance);
 }
 
-void RasterizerSceneGLES3::geometry_instance_set_transform(GeometryInstance *p_geometry_instance, const Transform3D &p_transform, const AABB &p_aabb, const AABB &p_transformed_aabbb) {
+void RasterizerSceneGLES3::geometry_instance_set_transform(GeometryInstance *p_geometry_instance, const Transform3D &p_transform, const AABB &p_aabb, const AABB &p_transformed_aabb) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->transform = p_transform;
+	ginstance->mirror = p_transform.basis.determinant() < 0;
+	ginstance->data->aabb = p_aabb;
+	ginstance->transformed_aabb = p_transformed_aabb;
+
+	Vector3 model_scale_vec = p_transform.basis.get_scale_abs();
+	// handle non uniform scale here
+
+	float max_scale = MAX(model_scale_vec.x, MAX(model_scale_vec.y, model_scale_vec.z));
+	float min_scale = MIN(model_scale_vec.x, MIN(model_scale_vec.y, model_scale_vec.z));
+	ginstance->non_uniform_scale = max_scale >= 0.0 && (min_scale / max_scale) < 0.9;
+
+	ginstance->lod_model_scale = max_scale;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_layer_mask(GeometryInstance *p_geometry_instance, uint32_t p_layer_mask) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->layer_mask = p_layer_mask;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_lod_bias(GeometryInstance *p_geometry_instance, float p_lod_bias) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->lod_bias = p_lod_bias;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_transparency(GeometryInstance *p_geometry_instance, float p_transparency) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->force_alpha = CLAMP(1.0 - p_transparency, 0, 1);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_fade_range(GeometryInstance *p_geometry_instance, bool p_enable_near, float p_near_begin, float p_near_end, bool p_enable_far, float p_far_begin, float p_far_end) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->fade_near = p_enable_near;
+	ginstance->fade_near_begin = p_near_begin;
+	ginstance->fade_near_end = p_near_end;
+	ginstance->fade_far = p_enable_far;
+	ginstance->fade_far_begin = p_far_begin;
+	ginstance->fade_far_end = p_far_end;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_parent_fade_alpha(GeometryInstance *p_geometry_instance, float p_alpha) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->parent_fade_alpha = p_alpha;
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_use_baked_light(GeometryInstance *p_geometry_instance, bool p_enable) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->use_baked_light = p_enable;
+
+	_geometry_instance_mark_dirty(ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_use_dynamic_gi(GeometryInstance *p_geometry_instance, bool p_enable) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->use_dynamic_gi = p_enable;
+	_geometry_instance_mark_dirty(ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_use_lightmap(GeometryInstance *p_geometry_instance, RID p_lightmap_instance, const Rect2 &p_lightmap_uv_scale, int p_lightmap_slice_index) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_lightmap_capture(GeometryInstance *p_geometry_instance, const Color *p_sh9) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_instance_shader_parameters_offset(GeometryInstance *p_geometry_instance, int32_t p_offset) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->shader_parameters_offset = p_offset;
+	_geometry_instance_mark_dirty(ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_cast_double_sided_shadows(GeometryInstance *p_geometry_instance, bool p_enable) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	ginstance->data->cast_double_sided_shadows = p_enable;
+	_geometry_instance_mark_dirty(ginstance);
 }
 
 uint32_t RasterizerSceneGLES3::geometry_instance_get_pair_mask() {
-	return 0;
+	return 0; //(1 << RS::INSTANCE_LIGHT);
+	// For now, nothing is paired
 }
 
 void RasterizerSceneGLES3::geometry_instance_pair_light_instances(GeometryInstance *p_geometry_instance, const RID *p_light_instances, uint32_t p_light_instance_count) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+
+	ginstance->omni_light_count = 0;
+	ginstance->spot_light_count = 0;
 }
 
 void RasterizerSceneGLES3::geometry_instance_pair_reflection_probe_instances(GeometryInstance *p_geometry_instance, const RID *p_reflection_probe_instances, uint32_t p_reflection_probe_instance_count) {
@@ -114,9 +218,314 @@ void RasterizerSceneGLES3::geometry_instance_pair_voxel_gi_instances(GeometryIns
 }
 
 void RasterizerSceneGLES3::geometry_instance_set_softshadow_projector_pairing(GeometryInstance *p_geometry_instance, bool p_softshadow, bool p_projector) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
 }
 
 void RasterizerSceneGLES3::geometry_instance_free(GeometryInstance *p_geometry_instance) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	ERR_FAIL_COND(!ginstance);
+	GeometryInstanceSurface *surf = ginstance->surface_caches;
+	while (surf) {
+		GeometryInstanceSurface *next = surf->next;
+		geometry_instance_surface_alloc.free(surf);
+		surf = next;
+	}
+	memdelete(ginstance->data);
+	geometry_instance_alloc.free(ginstance);
+}
+
+void RasterizerSceneGLES3::_geometry_instance_mark_dirty(GeometryInstance *p_geometry_instance) {
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+	if (ginstance->dirty_list_element.in_list()) {
+		return;
+	}
+
+	//clear surface caches
+	GeometryInstanceSurface *surf = ginstance->surface_caches;
+
+	while (surf) {
+		GeometryInstanceSurface *next = surf->next;
+		geometry_instance_surface_alloc.free(surf);
+		surf = next;
+	}
+
+	ginstance->surface_caches = nullptr;
+
+	geometry_instance_dirty_list.add(&ginstance->dirty_list_element);
+}
+
+void RasterizerSceneGLES3::_update_dirty_geometry_instances() {
+	while (geometry_instance_dirty_list.first()) {
+		_geometry_instance_update(geometry_instance_dirty_list.first()->self());
+	}
+}
+
+void RasterizerSceneGLES3::_geometry_instance_dependency_changed(RendererStorage::DependencyChangedNotification p_notification, RendererStorage::DependencyTracker *p_tracker) {
+	switch (p_notification) {
+		case RendererStorage::DEPENDENCY_CHANGED_MATERIAL:
+		case RendererStorage::DEPENDENCY_CHANGED_MESH:
+		case RendererStorage::DEPENDENCY_CHANGED_PARTICLES:
+		case RendererStorage::DEPENDENCY_CHANGED_MULTIMESH:
+		case RendererStorage::DEPENDENCY_CHANGED_SKELETON_DATA: {
+			static_cast<RasterizerSceneGLES3 *>(singleton)->_geometry_instance_mark_dirty(static_cast<GeometryInstance *>(p_tracker->userdata));
+		} break;
+		case RendererStorage::DEPENDENCY_CHANGED_MULTIMESH_VISIBLE_INSTANCES: {
+			GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_tracker->userdata);
+			if (ginstance->data->base_type == RS::INSTANCE_MULTIMESH) {
+				ginstance->instance_count = GLES3::MeshStorage::get_singleton()->multimesh_get_instances_to_draw(ginstance->data->base);
+			}
+		} break;
+		default: {
+			//rest of notifications of no interest
+		} break;
+	}
+}
+
+void RasterizerSceneGLES3::_geometry_instance_dependency_deleted(const RID &p_dependency, RendererStorage::DependencyTracker *p_tracker) {
+	static_cast<RasterizerSceneGLES3 *>(singleton)->_geometry_instance_mark_dirty(static_cast<GeometryInstance *>(p_tracker->userdata));
+}
+
+void RasterizerSceneGLES3::_geometry_instance_add_surface_with_material(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, GLES3::SceneMaterialData *p_material, uint32_t p_material_id, uint32_t p_shader_id, RID p_mesh) {
+	GLES3::MeshStorage *mesh_storage = GLES3::MeshStorage::get_singleton();
+
+	bool has_read_screen_alpha = p_material->shader_data->uses_screen_texture || p_material->shader_data->uses_depth_texture || p_material->shader_data->uses_normal_texture;
+	bool has_base_alpha = ((p_material->shader_data->uses_alpha && !p_material->shader_data->uses_alpha_clip) || has_read_screen_alpha);
+	bool has_blend_alpha = p_material->shader_data->uses_blend_alpha;
+	bool has_alpha = has_base_alpha || has_blend_alpha;
+
+	uint32_t flags = 0;
+
+	if (p_material->shader_data->uses_screen_texture) {
+		flags |= GeometryInstanceSurface::FLAG_USES_SCREEN_TEXTURE;
+	}
+
+	if (p_material->shader_data->uses_depth_texture) {
+		flags |= GeometryInstanceSurface::FLAG_USES_DEPTH_TEXTURE;
+	}
+
+	if (p_material->shader_data->uses_normal_texture) {
+		flags |= GeometryInstanceSurface::FLAG_USES_NORMAL_TEXTURE;
+	}
+
+	if (ginstance->data->cast_double_sided_shadows) {
+		flags |= GeometryInstanceSurface::FLAG_USES_DOUBLE_SIDED_SHADOWS;
+	}
+
+	if (has_alpha || has_read_screen_alpha || p_material->shader_data->depth_draw == GLES3::SceneShaderData::DEPTH_DRAW_DISABLED || p_material->shader_data->depth_test == GLES3::SceneShaderData::DEPTH_TEST_DISABLED) {
+		//material is only meant for alpha pass
+		flags |= GeometryInstanceSurface::FLAG_PASS_ALPHA;
+		if (p_material->shader_data->uses_depth_pre_pass && !(p_material->shader_data->depth_draw == GLES3::SceneShaderData::DEPTH_DRAW_DISABLED || p_material->shader_data->depth_test == GLES3::SceneShaderData::DEPTH_TEST_DISABLED)) {
+			flags |= GeometryInstanceSurface::FLAG_PASS_DEPTH;
+			flags |= GeometryInstanceSurface::FLAG_PASS_SHADOW;
+		}
+	} else {
+		flags |= GeometryInstanceSurface::FLAG_PASS_OPAQUE;
+		flags |= GeometryInstanceSurface::FLAG_PASS_DEPTH;
+		flags |= GeometryInstanceSurface::FLAG_PASS_SHADOW;
+	}
+
+	GLES3::SceneMaterialData *material_shadow = nullptr;
+	void *surface_shadow = nullptr;
+	if (!p_material->shader_data->uses_particle_trails && !p_material->shader_data->writes_modelview_or_projection && !p_material->shader_data->uses_vertex && !p_material->shader_data->uses_discard && !p_material->shader_data->uses_depth_pre_pass && !p_material->shader_data->uses_alpha_clip) {
+		flags |= GeometryInstanceSurface::FLAG_USES_SHARED_SHADOW_MATERIAL;
+		material_shadow = static_cast<GLES3::SceneMaterialData *>(GLES3::MaterialStorage::get_singleton()->material_get_data(scene_globals.default_material, RS::SHADER_SPATIAL));
+
+		RID shadow_mesh = mesh_storage->mesh_get_shadow_mesh(p_mesh);
+
+		if (shadow_mesh.is_valid()) {
+			surface_shadow = mesh_storage->mesh_get_surface(shadow_mesh, p_surface);
+		}
+
+	} else {
+		material_shadow = p_material;
+	}
+
+	GeometryInstanceSurface *sdcache = geometry_instance_surface_alloc.alloc();
+
+	sdcache->flags = flags;
+
+	sdcache->shader = p_material->shader_data;
+	sdcache->material = p_material;
+	sdcache->surface = mesh_storage->mesh_get_surface(p_mesh, p_surface);
+	sdcache->primitive = mesh_storage->mesh_surface_get_primitive(sdcache->surface);
+	sdcache->surface_index = p_surface;
+
+	if (ginstance->data->dirty_dependencies) {
+		storage->base_update_dependency(p_mesh, &ginstance->data->dependency_tracker);
+	}
+
+	//shadow
+	sdcache->shader_shadow = material_shadow->shader_data;
+	sdcache->material_shadow = material_shadow;
+
+	sdcache->surface_shadow = surface_shadow ? surface_shadow : sdcache->surface;
+
+	sdcache->owner = ginstance;
+
+	sdcache->next = ginstance->surface_caches;
+	ginstance->surface_caches = sdcache;
+
+	//sortkey
+
+	sdcache->sort.sort_key1 = 0;
+	sdcache->sort.sort_key2 = 0;
+
+	sdcache->sort.surface_index = p_surface;
+	sdcache->sort.material_id_low = p_material_id & 0x0000FFFF;
+	sdcache->sort.material_id_hi = p_material_id >> 16;
+	sdcache->sort.shader_id = p_shader_id;
+	sdcache->sort.geometry_id = p_mesh.get_local_index();
+	sdcache->sort.priority = p_material->priority;
+}
+
+void RasterizerSceneGLES3::_geometry_instance_add_surface_with_material_chain(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, GLES3::SceneMaterialData *p_material_data, RID p_mat_src, RID p_mesh) {
+	GLES3::SceneMaterialData *material_data = p_material_data;
+	GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();
+
+	_geometry_instance_add_surface_with_material(ginstance, p_surface, material_data, p_mat_src.get_local_index(), material_storage->material_get_shader_id(p_mat_src), p_mesh);
+
+	while (material_data->next_pass.is_valid()) {
+		RID next_pass = material_data->next_pass;
+		material_data = static_cast<GLES3::SceneMaterialData *>(material_storage->material_get_data(next_pass, RS::SHADER_SPATIAL));
+		if (!material_data || !material_data->shader_data->valid) {
+			break;
+		}
+		if (ginstance->data->dirty_dependencies) {
+			material_storage->material_update_dependency(next_pass, &ginstance->data->dependency_tracker);
+		}
+		_geometry_instance_add_surface_with_material(ginstance, p_surface, material_data, next_pass.get_local_index(), material_storage->material_get_shader_id(next_pass), p_mesh);
+	}
+}
+
+void RasterizerSceneGLES3::_geometry_instance_add_surface(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, RID p_material, RID p_mesh) {
+	GLES3::MaterialStorage *material_storage = GLES3::MaterialStorage::get_singleton();
+	RID m_src;
+
+	m_src = ginstance->data->material_override.is_valid() ? ginstance->data->material_override : p_material;
+
+	GLES3::SceneMaterialData *material_data = nullptr;
+
+	if (m_src.is_valid()) {
+		material_data = static_cast<GLES3::SceneMaterialData *>(material_storage->material_get_data(m_src, RS::SHADER_SPATIAL));
+		if (!material_data || !material_data->shader_data->valid) {
+			material_data = nullptr;
+		}
+	}
+
+	if (material_data) {
+		if (ginstance->data->dirty_dependencies) {
+			material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);
+		}
+	} else {
+		material_data = static_cast<GLES3::SceneMaterialData *>(material_storage->material_get_data(scene_globals.default_material, RS::SHADER_SPATIAL));
+		m_src = scene_globals.default_material;
+	}
+
+	ERR_FAIL_COND(!material_data);
+
+	_geometry_instance_add_surface_with_material_chain(ginstance, p_surface, material_data, m_src, p_mesh);
+
+	if (ginstance->data->material_overlay.is_valid()) {
+		m_src = ginstance->data->material_overlay;
+
+		material_data = static_cast<GLES3::SceneMaterialData *>(material_storage->material_get_data(m_src, RS::SHADER_SPATIAL));
+		if (material_data && material_data->shader_data->valid) {
+			if (ginstance->data->dirty_dependencies) {
+				material_storage->material_update_dependency(m_src, &ginstance->data->dependency_tracker);
+			}
+
+			_geometry_instance_add_surface_with_material_chain(ginstance, p_surface, material_data, m_src, p_mesh);
+		}
+	}
+}
+
+void RasterizerSceneGLES3::_geometry_instance_update(GeometryInstance *p_geometry_instance) {
+	GLES3::MeshStorage *mesh_storage = GLES3::MeshStorage::get_singleton();
+	GeometryInstanceGLES3 *ginstance = static_cast<GeometryInstanceGLES3 *>(p_geometry_instance);
+
+	if (ginstance->data->dirty_dependencies) {
+		ginstance->data->dependency_tracker.update_begin();
+	}
+
+	//add geometry for drawing
+	switch (ginstance->data->base_type) {
+		case RS::INSTANCE_MESH: {
+			const RID *materials = nullptr;
+			uint32_t surface_count;
+			RID mesh = ginstance->data->base;
+
+			materials = mesh_storage->mesh_get_surface_count_and_materials(mesh, surface_count);
+			if (materials) {
+				//if no materials, no surfaces.
+				const RID *inst_materials = ginstance->data->surface_materials.ptr();
+				uint32_t surf_mat_count = ginstance->data->surface_materials.size();
+
+				for (uint32_t j = 0; j < surface_count; j++) {
+					RID material = (j < surf_mat_count && inst_materials[j].is_valid()) ? inst_materials[j] : materials[j];
+					_geometry_instance_add_surface(ginstance, j, material, mesh);
+				}
+			}
+
+			ginstance->instance_count = 1;
+
+		} break;
+
+		case RS::INSTANCE_MULTIMESH: {
+			RID mesh = mesh_storage->multimesh_get_mesh(ginstance->data->base);
+			if (mesh.is_valid()) {
+				const RID *materials = nullptr;
+				uint32_t surface_count;
+
+				materials = mesh_storage->mesh_get_surface_count_and_materials(mesh, surface_count);
+				if (materials) {
+					for (uint32_t j = 0; j < surface_count; j++) {
+						_geometry_instance_add_surface(ginstance, j, materials[j], mesh);
+					}
+				}
+
+				ginstance->instance_count = mesh_storage->multimesh_get_instances_to_draw(ginstance->data->base);
+			}
+
+		} break;
+		case RS::INSTANCE_PARTICLES: {
+		} break;
+
+		default: {
+		}
+	}
+
+	//Fill push constant
+
+	bool store_transform = true;
+	ginstance->base_flags = 0;
+
+	if (ginstance->data->base_type == RS::INSTANCE_MULTIMESH) {
+		ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH;
+		if (mesh_storage->multimesh_get_transform_format(ginstance->data->base) == RS::MULTIMESH_TRANSFORM_2D) {
+			ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D;
+		}
+		if (mesh_storage->multimesh_uses_colors(ginstance->data->base)) {
+			ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR;
+		}
+		if (mesh_storage->multimesh_uses_custom_data(ginstance->data->base)) {
+			ginstance->base_flags |= INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA;
+		}
+
+		//ginstance->transforms_uniform_set = mesh_storage->multimesh_get_3d_uniform_set(ginstance->data->base, scene_globals.default_shader_rd, TRANSFORMS_UNIFORM_SET);
+
+	} else if (ginstance->data->base_type == RS::INSTANCE_PARTICLES) {
+	} else if (ginstance->data->base_type == RS::INSTANCE_MESH) {
+	}
+
+	ginstance->store_transform_cache = store_transform;
+
+	if (ginstance->data->dirty_dependencies) {
+		ginstance->data->dependency_tracker.update_end();
+		ginstance->data->dirty_dependencies = false;
+	}
+
+	ginstance->dirty_list_element.remove_from_list();
 }
 
 /* SHADOW ATLAS API */
@@ -277,10 +686,6 @@ void RasterizerSceneGLES3::_draw_sky(Environment *p_env, const CameraMatrix &p_p
 
 	ERR_FAIL_COND(!shader_data);
 
-	glDepthMask(GL_FALSE);
-	glDepthFunc(GL_LEQUAL);
-	glDisable(GL_BLEND);
-
 	//glBindBufferBase(GL_UNIFORM_BUFFER, 2, p_sky.directional light data); // Directional light data
 
 	// Camera
@@ -304,15 +709,9 @@ void RasterizerSceneGLES3::_draw_sky(Environment *p_env, const CameraMatrix &p_p
 	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::PROJECTION, camera.matrix[2][0], camera.matrix[0][0], camera.matrix[2][1], camera.matrix[1][1], shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
 	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::POSITION, p_transform.origin, shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
 	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::TIME, time, shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
-	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::EXPOSURE, p_env->exposure, shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
-	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::TONEMAPPER, p_env->tone_mapper, shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
-	GLES3::MaterialStorage::get_singleton()->shaders.sky_shader.version_set_uniform(SkyShaderGLES3::WHITE, p_env->white, shader_data->version, SkyShaderGLES3::MODE_BACKGROUND);
 	// Bind a vertex array or else OpenGL complains. We won't actually use it
 	glBindVertexArray(sky_globals.quad_array);
 	glDrawArrays(GL_TRIANGLES, 0, 3);
-
-	//glDepthMask(GL_FALSE); // Leave off for transparent pass
-	glDepthFunc(GL_LESS);
 }
 
 Ref<Image> RasterizerSceneGLES3::sky_bake_panorama(RID p_sky, float p_energy, bool p_bake_irradiance, const Size2i &p_size) {
@@ -643,20 +1042,267 @@ void RasterizerSceneGLES3::voxel_gi_update(RID p_probe, bool p_update_light_inst
 void RasterizerSceneGLES3::voxel_gi_set_quality(RS::VoxelGIQuality) {
 }
 
+void RasterizerSceneGLES3::_fill_render_list(RenderListType p_render_list, const RenderDataGLES3 *p_render_data, PassMode p_pass_mode, bool p_append) {
+	GLES3::MeshStorage *mesh_storage = GLES3::MeshStorage::get_singleton();
+
+	if (p_render_list == RENDER_LIST_OPAQUE) {
+		scene_state.used_screen_texture = false;
+		scene_state.used_normal_texture = false;
+		scene_state.used_depth_texture = false;
+	}
+
+	Plane near_plane;
+	if (p_render_data->cam_orthogonal) {
+		near_plane = Plane(-p_render_data->cam_transform.basis.get_column(Vector3::AXIS_Z), p_render_data->cam_transform.origin);
+		near_plane.d += p_render_data->cam_projection.get_z_near();
+	}
+	float z_max = p_render_data->cam_projection.get_z_far() - p_render_data->cam_projection.get_z_near();
+
+	RenderList *rl = &render_list[p_render_list];
+
+	// Parse any updates on our geometry, updates surface caches and such
+	_update_dirty_geometry_instances();
+
+	if (!p_append) {
+		rl->clear();
+		if (p_render_list == RENDER_LIST_OPAQUE) {
+			render_list[RENDER_LIST_ALPHA].clear(); //opaque fills alpha too
+		}
+	}
+
+	//fill list
+
+	for (int i = 0; i < (int)p_render_data->instances->size(); i++) {
+		GeometryInstanceGLES3 *inst = static_cast<GeometryInstanceGLES3 *>((*p_render_data->instances)[i]);
+
+		if (p_render_data->cam_orthogonal) {
+			Vector3 support_min = inst->transformed_aabb.get_support(-near_plane.normal);
+			inst->depth = near_plane.distance_to(support_min);
+		} else {
+			Vector3 aabb_center = inst->transformed_aabb.position + (inst->transformed_aabb.size * 0.5);
+			inst->depth = p_render_data->cam_transform.origin.distance_to(aabb_center);
+		}
+		uint32_t depth_layer = CLAMP(int(inst->depth * 16 / z_max), 0, 15);
+
+		uint32_t flags = inst->base_flags; //fill flags if appropriate
+
+		if (inst->non_uniform_scale) {
+			flags |= INSTANCE_DATA_FLAGS_NON_UNIFORM_SCALE;
+		}
+
+		//Process lights here, determine if they need extra passes
+		if (p_pass_mode == PASS_MODE_COLOR) {
+		}
+
+		inst->flags_cache = flags;
+
+		GeometryInstanceSurface *surf = inst->surface_caches;
+
+		while (surf) {
+			// LOD
+
+			if (p_render_data->screen_mesh_lod_threshold > 0.0 && mesh_storage->mesh_surface_has_lod(surf->surface)) {
+				//lod
+				Vector3 lod_support_min = inst->transformed_aabb.get_support(-p_render_data->lod_camera_plane.normal);
+				Vector3 lod_support_max = inst->transformed_aabb.get_support(p_render_data->lod_camera_plane.normal);
+
+				float distance_min = p_render_data->lod_camera_plane.distance_to(lod_support_min);
+				float distance_max = p_render_data->lod_camera_plane.distance_to(lod_support_max);
+
+				float distance = 0.0;
+
+				if (distance_min * distance_max < 0.0) {
+					//crossing plane
+					distance = 0.0;
+				} else if (distance_min >= 0.0) {
+					distance = distance_min;
+				} else if (distance_max <= 0.0) {
+					distance = -distance_max;
+				}
+
+				if (p_render_data->cam_orthogonal) {
+					distance = 1.0;
+				}
+
+				uint32_t indices;
+				surf->lod_index = mesh_storage->mesh_surface_get_lod(surf->surface, inst->lod_model_scale * inst->lod_bias, distance * p_render_data->lod_distance_multiplier, p_render_data->screen_mesh_lod_threshold, &indices);
+				/*
+				if (p_render_data->render_info) {
+					indices = _indices_to_primitives(surf->primitive, indices);
+					if (p_render_list == RENDER_LIST_OPAQUE) { //opaque
+						p_render_data->render_info->info[RS::VIEWPORT_RENDER_INFO_TYPE_VISIBLE][RS::VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME] += indices;
+					} else if (p_render_list == RENDER_LIST_SECONDARY) { //shadow
+						p_render_data->render_info->info[RS::VIEWPORT_RENDER_INFO_TYPE_SHADOW][RS::VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME] += indices;
+					}
+				}
+				*/
+			} else {
+				surf->lod_index = 0;
+				/*
+				if (p_render_data->render_info) {
+					uint32_t to_draw = mesh_storage->mesh_surface_get_vertices_drawn_count(surf->surface);
+					to_draw = _indices_to_primitives(surf->primitive, to_draw);
+					to_draw *= inst->instance_count;
+					if (p_render_list == RENDER_LIST_OPAQUE) { //opaque
+						p_render_data->render_info->info[RS::VIEWPORT_RENDER_INFO_TYPE_VISIBLE][RS::VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME] += mesh_storage->mesh_surface_get_vertices_drawn_count(surf->surface);
+					} else if (p_render_list == RENDER_LIST_SECONDARY) { //shadow
+						p_render_data->render_info->info[RS::VIEWPORT_RENDER_INFO_TYPE_SHADOW][RS::VIEWPORT_RENDER_INFO_PRIMITIVES_IN_FRAME] += mesh_storage->mesh_surface_get_vertices_drawn_count(surf->surface);
+					}
+				}
+				*/
+			}
+
+			// ADD Element
+			if (p_pass_mode == PASS_MODE_COLOR) {
+#ifdef DEBUG_ENABLED
+				bool force_alpha = unlikely(get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW);
+#else
+				bool force_alpha = false;
+#endif
+				if (!force_alpha && (surf->flags & GeometryInstanceSurface::FLAG_PASS_OPAQUE)) {
+					rl->add_element(surf);
+				}
+				if (force_alpha || (surf->flags & GeometryInstanceSurface::FLAG_PASS_ALPHA)) {
+					render_list[RENDER_LIST_ALPHA].add_element(surf);
+				}
+
+				if (surf->flags & GeometryInstanceSurface::FLAG_USES_SCREEN_TEXTURE) {
+					scene_state.used_screen_texture = true;
+				}
+				if (surf->flags & GeometryInstanceSurface::FLAG_USES_NORMAL_TEXTURE) {
+					scene_state.used_normal_texture = true;
+				}
+				if (surf->flags & GeometryInstanceSurface::FLAG_USES_DEPTH_TEXTURE) {
+					scene_state.used_depth_texture = true;
+				}
+
+				/*
+					Add elements here if there are shadows
+				*/
+
+			} else if (p_pass_mode == PASS_MODE_SHADOW) {
+				if (surf->flags & GeometryInstanceSurface::FLAG_PASS_SHADOW) {
+					rl->add_element(surf);
+				}
+			} else {
+				if (surf->flags & (GeometryInstanceSurface::FLAG_PASS_DEPTH | GeometryInstanceSurface::FLAG_PASS_OPAQUE)) {
+					rl->add_element(surf);
+				}
+			}
+
+			surf->sort.depth_layer = depth_layer;
+
+			surf = surf->next;
+		}
+	}
+}
+
+void RasterizerSceneGLES3::_setup_environment(const RenderDataGLES3 *p_render_data, bool p_no_fog, const Size2i &p_screen_size, bool p_flip_y, const Color &p_default_bg_color, bool p_pancake_shadows) {
+	CameraMatrix correction;
+	correction.set_depth_correction(p_flip_y);
+	CameraMatrix projection = correction * p_render_data->cam_projection;
+	//store camera into ubo
+	RasterizerStorageGLES3::store_camera(projection, scene_state.ubo.projection_matrix);
+	RasterizerStorageGLES3::store_camera(projection.inverse(), scene_state.ubo.inv_projection_matrix);
+	RasterizerStorageGLES3::store_transform(p_render_data->cam_transform, scene_state.ubo.inv_view_matrix);
+	RasterizerStorageGLES3::store_transform(p_render_data->cam_transform.affine_inverse(), scene_state.ubo.view_matrix);
+
+	scene_state.ubo.directional_light_count = 1;
+
+	scene_state.ubo.z_far = p_render_data->z_far;
+	scene_state.ubo.z_near = p_render_data->z_near;
+
+	scene_state.ubo.pancake_shadows = p_pancake_shadows;
+
+	scene_state.ubo.viewport_size[0] = p_screen_size.x;
+	scene_state.ubo.viewport_size[1] = p_screen_size.y;
+
+	Size2 screen_pixel_size = Vector2(1.0, 1.0) / Size2(p_screen_size);
+	scene_state.ubo.screen_pixel_size[0] = screen_pixel_size.x;
+	scene_state.ubo.screen_pixel_size[1] = screen_pixel_size.y;
+
+	//time global variables
+	scene_state.ubo.time = time;
+
+	if (is_environment(p_render_data->environment)) {
+		Environment *env = environment_owner.get_or_null(p_render_data->environment);
+		RS::EnvironmentBG env_bg = env->background;
+		RS::EnvironmentAmbientSource ambient_src = env->ambient_source;
+
+		float bg_energy = env->bg_energy;
+		scene_state.ubo.ambient_light_color_energy[3] = bg_energy;
+
+		scene_state.ubo.ambient_color_sky_mix = env->ambient_sky_contribution;
+
+		//ambient
+		if (ambient_src == RS::ENV_AMBIENT_SOURCE_BG && (env_bg == RS::ENV_BG_CLEAR_COLOR || env_bg == RS::ENV_BG_COLOR)) {
+			Color color = env_bg == RS::ENV_BG_CLEAR_COLOR ? p_default_bg_color : env->bg_color;
+			color = color.srgb_to_linear();
+
+			scene_state.ubo.ambient_light_color_energy[0] = color.r * bg_energy;
+			scene_state.ubo.ambient_light_color_energy[1] = color.g * bg_energy;
+			scene_state.ubo.ambient_light_color_energy[2] = color.b * bg_energy;
+		} else {
+			float energy = env->ambient_light_energy;
+			Color color = env->ambient_light;
+			color = color.srgb_to_linear();
+			scene_state.ubo.ambient_light_color_energy[0] = color.r * energy;
+			scene_state.ubo.ambient_light_color_energy[1] = color.g * energy;
+			scene_state.ubo.ambient_light_color_energy[2] = color.b * energy;
+
+			Basis sky_transform = env->sky_orientation;
+			sky_transform = sky_transform.inverse() * p_render_data->cam_transform.basis;
+			RasterizerStorageGLES3::store_transform_3x3(sky_transform, scene_state.ubo.radiance_inverse_xform);
+		}
+
+		scene_state.ubo.fog_enabled = env->fog_enabled;
+		scene_state.ubo.fog_density = env->fog_density;
+		scene_state.ubo.fog_height = env->fog_height;
+		scene_state.ubo.fog_height_density = env->fog_height_density;
+		scene_state.ubo.fog_aerial_perspective = env->fog_aerial_perspective;
+
+		Color fog_color = env->fog_light_color.srgb_to_linear();
+		float fog_energy = env->fog_light_energy;
+
+		scene_state.ubo.fog_light_color[0] = fog_color.r * fog_energy;
+		scene_state.ubo.fog_light_color[1] = fog_color.g * fog_energy;
+		scene_state.ubo.fog_light_color[2] = fog_color.b * fog_energy;
+
+		scene_state.ubo.fog_sun_scatter = env->fog_sun_scatter;
+
+	} else {
+	}
+
+	if (scene_state.ubo_buffer == 0) {
+		glGenBuffers(1, &scene_state.ubo_buffer);
+	}
+	glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_DATA_UNIFORM_LOCATION, scene_state.ubo_buffer);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(SceneState::UBO), &scene_state.ubo, GL_STREAM_DRAW);
+	glBindBuffer(GL_UNIFORM_BUFFER, 0);
+}
+
 void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *p_camera_data, const PagedArray<GeometryInstance *> &p_instances, const PagedArray<RID> &p_lights, const PagedArray<RID> &p_reflection_probes, const PagedArray<RID> &p_voxel_gi_instances, const PagedArray<RID> &p_decals, const PagedArray<RID> &p_lightmaps, const PagedArray<RID> &p_fog_volumes, RID p_environment, RID p_camera_effects, RID p_shadow_atlas, RID p_occluder_debug_tex, RID p_reflection_atlas, RID p_reflection_probe, int p_reflection_probe_pass, float p_screen_mesh_lod_threshold, const RenderShadowData *p_render_shadows, int p_render_shadow_count, const RenderSDFGIData *p_render_sdfgi_regions, int p_render_sdfgi_region_count, const RenderSDFGIUpdateData *p_sdfgi_update_data, RendererScene::RenderInfo *r_render_info) {
 	GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
+	GLES3::Config *config = GLES3::Config::get_singleton();
 	RENDER_TIMESTAMP("Setup 3D Scene");
-	// assign render data
+
+	RenderBuffers *rb = nullptr;
+	if (p_render_buffers.is_valid()) {
+		rb = render_buffers_owner.get_or_null(p_render_buffers);
+		ERR_FAIL_COND(!rb);
+	}
+
+	// Assign render data
 	// Use the format from rendererRD
 	RenderDataGLES3 render_data;
 	{
 		render_data.render_buffers = p_render_buffers;
-
+		render_data.transparent_bg = rb->is_transparent;
 		// Our first camera is used by default
 		render_data.cam_transform = p_camera_data->main_transform;
 		render_data.cam_projection = p_camera_data->main_projection;
 		render_data.view_projection[0] = p_camera_data->main_projection;
-		render_data.cam_ortogonal = p_camera_data->is_orthogonal;
+		render_data.cam_orthogonal = p_camera_data->is_orthogonal;
 
 		render_data.view_count = p_camera_data->view_count;
 		for (uint32_t v = 0; v < p_camera_data->view_count; v++) {
@@ -669,10 +1315,6 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 		render_data.instances = &p_instances;
 		render_data.lights = &p_lights;
 		render_data.reflection_probes = &p_reflection_probes;
-		//render_data.voxel_gi_instances = &p_voxel_gi_instances;
-		//render_data.decals = &p_decals;
-		//render_data.lightmaps = &p_lightmaps;
-		//render_data.fog_volumes = &p_fog_volumes;
 		render_data.environment = p_environment;
 		render_data.camera_effects = p_camera_effects;
 		render_data.shadow_atlas = p_shadow_atlas;
@@ -699,19 +1341,15 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 		render_data.reflection_probes = &empty;
 	}
 
-	RenderBuffers *rb = nullptr;
-	//RasterizerStorageGLES3::RenderTarget *rt = nullptr;
-	if (p_render_buffers.is_valid()) {
-		rb = render_buffers_owner.get_or_null(p_render_buffers);
-		ERR_FAIL_COND(!rb);
-		//rt = texture_storage->render_target_owner.get_or_null(rb->render_target);
-		//ERR_FAIL_COND(!rt);
-	}
+	bool reverse_cull = false;
 
 	///////////
 	// Fill Light lists here
 	//////////
 
+	GLuint global_buffer = GLES3::MaterialStorage::get_singleton()->global_variables_get_uniform_buffer();
+	glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_GLOBALS_UNIFORM_LOCATION, global_buffer);
+
 	Color clear_color;
 	if (p_render_buffers.is_valid()) {
 		clear_color = texture_storage->render_target_get_clear_request_color(rb->render_target);
@@ -722,15 +1360,86 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 	Environment *env = environment_owner.get_or_null(p_environment);
 
 	bool fb_cleared = false;
-	glEnable(GL_DEPTH_TEST);
-	glDepthFunc(GL_LESS);
-	glDepthMask(GL_TRUE);
 
-	/* Depth Prepass */
+	Size2i screen_size;
+	screen_size.x = rb->width;
+	screen_size.y = rb->height;
+
+	SceneState::TonemapUBO tonemap_ubo;
+	if (is_environment(p_environment)) {
+		tonemap_ubo.exposure = env->exposure;
+		tonemap_ubo.white = env->white;
+		tonemap_ubo.tonemapper = int32_t(env->tone_mapper);
+	}
+
+	if (scene_state.tonemap_buffer == 0) {
+		// Only create if using 3D
+		glGenBuffers(1, &scene_state.tonemap_buffer);
+	}
+	glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_TONEMAP_UNIFORM_LOCATION, scene_state.tonemap_buffer);
+	glBufferData(GL_UNIFORM_BUFFER, sizeof(SceneState::TonemapUBO), &tonemap_ubo, GL_STREAM_DRAW);
+
+	_setup_environment(&render_data, render_data.reflection_probe.is_valid(), screen_size, !render_data.reflection_probe.is_valid(), clear_color, false);
+
+	_fill_render_list(RENDER_LIST_OPAQUE, &render_data, PASS_MODE_COLOR);
+	render_list[RENDER_LIST_OPAQUE].sort_by_key();
+	render_list[RENDER_LIST_ALPHA].sort_by_reverse_depth_and_priority();
 
 	glBindFramebuffer(GL_FRAMEBUFFER, rb->framebuffer);
 	glViewport(0, 0, rb->width, rb->height);
 
+	// Do depth prepass if it's explicitly enabled
+	bool use_depth_prepass = config->use_depth_prepass;
+
+	// Don't do depth prepass we are rendering overdraw
+	use_depth_prepass = use_depth_prepass && get_debug_draw_mode() != RS::VIEWPORT_DEBUG_DRAW_OVERDRAW;
+
+	if (use_depth_prepass) {
+		//pre z pass
+
+		glDisable(GL_BLEND);
+		glDepthMask(GL_TRUE);
+		glEnable(GL_DEPTH_TEST);
+		glDepthFunc(GL_LEQUAL);
+		glDisable(GL_SCISSOR_TEST);
+		glCullFace(GL_BACK);
+		glEnable(GL_CULL_FACE);
+		scene_state.cull_mode = GLES3::SceneShaderData::CULL_BACK;
+
+		glColorMask(0, 0, 0, 0);
+		glClearDepth(1.0f);
+		glClear(GL_DEPTH_BUFFER_BIT);
+
+		uint32_t spec_constant_base_flags = 0;
+
+		RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), reverse_cull, spec_constant_base_flags, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, render_data.lod_camera_plane, render_data.lod_distance_multiplier, render_data.screen_mesh_lod_threshold);
+		_render_list_template<PASS_MODE_DEPTH>(&render_list_params, &render_data, 0, render_list[RENDER_LIST_OPAQUE].elements.size());
+
+		glColorMask(1, 1, 1, 1);
+
+		fb_cleared = true;
+		scene_state.used_depth_prepass = true;
+	} else {
+		scene_state.used_depth_prepass = false;
+	}
+
+	glBlendEquation(GL_FUNC_ADD);
+
+	if (render_data.transparent_bg) {
+		glBlendFuncSeparate(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA, GL_ONE, GL_ONE_MINUS_SRC_ALPHA);
+		glEnable(GL_BLEND);
+	} else {
+		glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
+		glDisable(GL_BLEND);
+	}
+	scene_state.current_blend_mode = GLES3::SceneShaderData::BLEND_MODE_MIX;
+
+	glEnable(GL_DEPTH_TEST);
+	glDepthFunc(GL_LEQUAL);
+	glDepthMask(GL_TRUE);
+	scene_state.current_depth_test = GLES3::SceneShaderData::DEPTH_TEST_ENABLED;
+	scene_state.current_depth_draw = GLES3::SceneShaderData::DEPTH_DRAW_OPAQUE;
+
 	if (!fb_cleared) {
 		glClearDepth(1.0f);
 		glClear(GL_DEPTH_BUFFER_BIT);
@@ -740,9 +1449,6 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 	bool keep_color = false;
 
 	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
-		clear_color = Color(0, 0, 0, 1);
-	}
-	if (get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_OVERDRAW) {
 		clear_color = Color(0, 0, 0, 1); //in overdraw mode, BG should always be black
 	} else if (is_environment(p_environment)) {
 		RS::EnvironmentBG bg_mode = environment_get_background(p_environment);
@@ -773,16 +1479,43 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 			default: {
 			}
 		}
+		// Draw sky cubemap
 	}
 
 	if (!keep_color) {
 		glClearBufferfv(GL_COLOR, 0, clear_color.components);
 	}
 
+	uint32_t spec_constant_base_flags = 0;
+	//Render Opaque Objects
+	RenderListParameters render_list_params(render_list[RENDER_LIST_OPAQUE].elements.ptr(), render_list[RENDER_LIST_OPAQUE].elements.size(), reverse_cull, spec_constant_base_flags, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, render_data.lod_camera_plane, render_data.lod_distance_multiplier, render_data.screen_mesh_lod_threshold);
+
+	_render_list_template<PASS_MODE_COLOR>(&render_list_params, &render_data, 0, render_list[RENDER_LIST_OPAQUE].elements.size());
+
 	if (draw_sky) {
+		if (scene_state.current_depth_test != GLES3::SceneShaderData::DEPTH_TEST_ENABLED) {
+			glEnable(GL_DEPTH_TEST);
+			scene_state.current_depth_test = GLES3::SceneShaderData::DEPTH_TEST_ENABLED;
+		}
+		glEnable(GL_DEPTH_TEST);
+		glDepthMask(GL_FALSE);
+		glDisable(GL_BLEND);
+		glEnable(GL_CULL_FACE);
+		glCullFace(GL_BACK);
+		scene_state.current_depth_test = GLES3::SceneShaderData::DEPTH_TEST_ENABLED;
+		scene_state.current_depth_draw = GLES3::SceneShaderData::DEPTH_DRAW_DISABLED;
+		scene_state.cull_mode = GLES3::SceneShaderData::CULL_BACK;
+
 		_draw_sky(env, render_data.cam_projection, render_data.cam_transform);
 	}
 
+	glEnable(GL_BLEND);
+
+	//Render transparent pass
+	RenderListParameters render_list_params_alpha(render_list[RENDER_LIST_ALPHA].elements.ptr(), render_list[RENDER_LIST_ALPHA].elements.size(), reverse_cull, spec_constant_base_flags, get_debug_draw_mode() == RS::VIEWPORT_DEBUG_DRAW_WIREFRAME, render_data.lod_camera_plane, render_data.lod_distance_multiplier, render_data.screen_mesh_lod_threshold);
+
+	_render_list_template<PASS_MODE_COLOR_TRANSPARENT>(&render_list_params_alpha, &render_data, 0, render_list[RENDER_LIST_ALPHA].elements.size(), true);
+
 	if (p_render_buffers.is_valid()) {
 		/*
 		RENDER_TIMESTAMP("Tonemap");
@@ -791,9 +1524,225 @@ void RasterizerSceneGLES3::render_scene(RID p_render_buffers, const CameraData *
 
 		_render_buffers_debug_draw(p_render_buffers, p_shadow_atlas, p_occluder_debug_tex);
 	}
+	glDisable(GL_BLEND);
 	texture_storage->render_target_disable_clear_request(rb->render_target);
 }
 
+template <PassMode p_pass_mode>
+void RasterizerSceneGLES3::_render_list_template(RenderListParameters *p_params, const RenderDataGLES3 *p_render_data, uint32_t p_from_element, uint32_t p_to_element, bool p_alpha_pass) {
+	GLES3::MeshStorage *mesh_storage = GLES3::MeshStorage::get_singleton();
+
+	GLuint prev_vertex_array_gl = 0;
+	GLuint prev_index_array_gl = 0;
+
+	GLES3::SceneMaterialData *prev_material_data = nullptr;
+	GLES3::SceneShaderData *prev_shader = nullptr;
+
+	SceneShaderGLES3::ShaderVariant shader_variant = SceneShaderGLES3::MODE_COLOR; // Assigned to silence wrong -Wmaybe-initialized.
+
+	switch (p_pass_mode) {
+		case PASS_MODE_COLOR:
+		case PASS_MODE_COLOR_TRANSPARENT: {
+		} break;
+		case PASS_MODE_COLOR_ADDITIVE: {
+			shader_variant = SceneShaderGLES3::MODE_ADDITIVE;
+		} break;
+		case PASS_MODE_SHADOW:
+		case PASS_MODE_DEPTH: {
+			shader_variant = SceneShaderGLES3::MODE_DEPTH;
+		} break;
+	}
+
+	for (uint32_t i = p_from_element; i < p_to_element; i++) {
+		const GeometryInstanceSurface *surf = p_params->elements[i];
+		const GeometryInstanceGLES3 *inst = surf->owner;
+
+		if (p_pass_mode == PASS_MODE_COLOR && !(surf->flags & GeometryInstanceSurface::FLAG_PASS_OPAQUE)) {
+			continue; // Objects with "Depth-prepass" transparency are included in both render lists, but should only be rendered in the transparent pass
+		}
+
+		if (inst->instance_count == 0) {
+			continue;
+		}
+
+		//uint32_t base_spec_constants = p_params->spec_constant_base_flags;
+
+		GLES3::SceneShaderData *shader;
+		GLES3::SceneMaterialData *material_data;
+		void *mesh_surface;
+
+		if (p_pass_mode == PASS_MODE_SHADOW) {
+			shader = surf->shader_shadow;
+			material_data = surf->material_shadow;
+			mesh_surface = surf->surface_shadow;
+		} else {
+			shader = surf->shader;
+			material_data = surf->material;
+			mesh_surface = surf->surface;
+		}
+
+		if (!mesh_surface) {
+			continue;
+		}
+
+		if (p_pass_mode == PASS_MODE_COLOR_TRANSPARENT) {
+			if (scene_state.current_depth_test != shader->depth_test) {
+				if (shader->depth_test == GLES3::SceneShaderData::DEPTH_TEST_DISABLED) {
+					glDisable(GL_DEPTH_TEST);
+				} else {
+					glEnable(GL_DEPTH_TEST);
+				}
+				scene_state.current_depth_test = shader->depth_test;
+			}
+		}
+
+		if (scene_state.current_depth_draw != shader->depth_draw) {
+			switch (shader->depth_draw) {
+				case GLES3::SceneShaderData::DEPTH_DRAW_OPAQUE: {
+					glDepthMask(p_pass_mode == PASS_MODE_COLOR);
+				} break;
+				case GLES3::SceneShaderData::DEPTH_DRAW_ALWAYS: {
+					glDepthMask(GL_TRUE);
+				} break;
+				case GLES3::SceneShaderData::DEPTH_DRAW_DISABLED: {
+					glDepthMask(GL_FALSE);
+				} break;
+			}
+
+			scene_state.current_depth_draw = shader->depth_draw;
+		}
+
+		if (p_pass_mode == PASS_MODE_COLOR_TRANSPARENT || p_pass_mode == PASS_MODE_COLOR_ADDITIVE) {
+			GLES3::SceneShaderData::BlendMode desired_blend_mode;
+			if (p_pass_mode == PASS_MODE_COLOR_ADDITIVE) {
+				desired_blend_mode = GLES3::SceneShaderData::BLEND_MODE_ADD;
+			} else {
+				desired_blend_mode = shader->blend_mode;
+			}
+
+			if (desired_blend_mode != scene_state.current_blend_mode) {
+				switch (desired_blend_mode) {
+					case GLES3::SceneShaderData::BLEND_MODE_MIX: {
+						glBlendEquation(GL_FUNC_ADD);
+						if (p_render_data->transparent_bg) {
+							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);
+						}
+
+					} break;
+					case GLES3::SceneShaderData::BLEND_MODE_ADD: {
+						glBlendEquation(GL_FUNC_ADD);
+						glBlendFunc(p_pass_mode == PASS_MODE_COLOR_TRANSPARENT ? GL_SRC_ALPHA : GL_ONE, GL_ONE);
+
+					} break;
+					case GLES3::SceneShaderData::BLEND_MODE_SUB: {
+						glBlendEquation(GL_FUNC_REVERSE_SUBTRACT);
+						glBlendFunc(GL_SRC_ALPHA, GL_ONE);
+					} break;
+					case GLES3::SceneShaderData::BLEND_MODE_MUL: {
+						glBlendEquation(GL_FUNC_ADD);
+						if (p_render_data->transparent_bg) {
+							glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_DST_ALPHA, GL_ZERO);
+						} else {
+							glBlendFuncSeparate(GL_DST_COLOR, GL_ZERO, GL_ZERO, GL_ONE);
+						}
+
+					} break;
+					case GLES3::SceneShaderData::BLEND_MODE_ALPHA_TO_COVERAGE: {
+						// Do nothing for now.
+					} break;
+				}
+				scene_state.current_blend_mode = desired_blend_mode;
+			}
+		}
+
+		//find cull variant
+		GLES3::SceneShaderData::Cull cull_mode = shader->cull_mode;
+
+		if ((surf->flags & GeometryInstanceSurface::FLAG_USES_DOUBLE_SIDED_SHADOWS)) {
+			cull_mode = GLES3::SceneShaderData::CULL_DISABLED;
+		} else {
+			bool mirror = inst->mirror;
+			if (p_params->reverse_cull) {
+				mirror = !mirror;
+			}
+			if (cull_mode == GLES3::SceneShaderData::CULL_FRONT && mirror) {
+				cull_mode = GLES3::SceneShaderData::CULL_BACK;
+			} else if (cull_mode == GLES3::SceneShaderData::CULL_BACK && mirror) {
+				cull_mode = GLES3::SceneShaderData::CULL_FRONT;
+			}
+		}
+
+		if (scene_state.cull_mode != cull_mode) {
+			if (cull_mode == GLES3::SceneShaderData::CULL_DISABLED) {
+				glDisable(GL_CULL_FACE);
+			} else {
+				if (scene_state.cull_mode == GLES3::SceneShaderData::CULL_DISABLED) {
+					// Last time was disabled, so enable and set proper face.
+					glEnable(GL_CULL_FACE);
+				}
+				glCullFace(cull_mode == GLES3::SceneShaderData::CULL_FRONT ? GL_FRONT : GL_BACK);
+			}
+			scene_state.cull_mode = cull_mode;
+		}
+
+		RS::PrimitiveType primitive = surf->primitive;
+		static const GLenum prim[5] = { GL_POINTS, GL_LINES, GL_LINE_STRIP, GL_TRIANGLES, GL_TRIANGLE_STRIP };
+		GLenum primitive_gl = prim[int(primitive)];
+
+		GLuint vertex_array_gl = 0;
+		GLuint index_array_gl = 0;
+
+		//skeleton and blend shape
+		if (surf->owner->mesh_instance.is_valid()) {
+			mesh_storage->mesh_instance_surface_get_vertex_arrays_and_format(surf->owner->mesh_instance, surf->surface_index, shader->vertex_input_mask, vertex_array_gl);
+		} else {
+			mesh_storage->mesh_surface_get_vertex_arrays_and_format(mesh_surface, shader->vertex_input_mask, vertex_array_gl);
+		}
+
+		index_array_gl = mesh_storage->mesh_surface_get_index_buffer(mesh_surface, surf->lod_index);
+
+		if (prev_vertex_array_gl != vertex_array_gl) {
+			glBindVertexArray(vertex_array_gl);
+			prev_vertex_array_gl = vertex_array_gl;
+		}
+
+		bool use_index_buffer = false;
+		if (prev_index_array_gl != index_array_gl) {
+			if (index_array_gl != 0) {
+				// Bind index each time so we can use LODs
+				glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, index_array_gl);
+				use_index_buffer = true;
+			}
+			prev_index_array_gl = index_array_gl;
+		}
+
+		// Update pipeline information here
+
+		Transform3D world_transform;
+		if (inst->store_transform_cache) {
+			world_transform = inst->transform;
+		}
+
+		if (prev_material_data != material_data) {
+			material_data->bind_uniforms();
+		}
+
+		if (prev_shader != shader) {
+			GLES3::MaterialStorage::get_singleton()->shaders.scene_shader.version_bind_shader(shader->version, shader_variant);
+		}
+
+		GLES3::MaterialStorage::get_singleton()->shaders.scene_shader.version_set_uniform(SceneShaderGLES3::WORLD_TRANSFORM, world_transform, shader->version, shader_variant);
+
+		if (use_index_buffer) {
+			glDrawElements(primitive_gl, mesh_storage->mesh_surface_get_vertices_drawn_count(mesh_surface), mesh_storage->mesh_surface_get_index_type(mesh_surface), 0);
+		} else {
+			glDrawArrays(primitive_gl, 0, mesh_storage->mesh_surface_get_vertices_drawn_count(mesh_surface));
+		}
+	}
+}
+
 void RasterizerSceneGLES3::render_material(const Transform3D &p_cam_transform, const CameraMatrix &p_cam_projection, bool p_cam_orthogonal, const PagedArray<GeometryInstance *> &p_instances, RID p_framebuffer, const Rect2i &p_region) {
 }
 
@@ -929,6 +1878,8 @@ void RasterizerSceneGLES3::render_buffers_configure(RID p_render_buffers, RID p_
 
 	GLES3::RenderTarget *rt = texture_storage->get_render_target(p_render_target);
 
+	rb->is_transparent = rt->flags[RendererTextureStorage::RENDER_TARGET_TRANSPARENT];
+
 	// framebuffer
 	glGenFramebuffers(1, &rb->framebuffer);
 	glBindFramebuffer(GL_FRAMEBUFFER, rb->framebuffer);
diff --git a/drivers/gles3/rasterizer_scene_gles3.h b/drivers/gles3/rasterizer_scene_gles3.h
index 13b3b007a2..ac2f3c932a 100644
--- a/drivers/gles3/rasterizer_scene_gles3.h
+++ b/drivers/gles3/rasterizer_scene_gles3.h
@@ -34,6 +34,7 @@
 #ifdef GLES3_ENABLED
 
 #include "core/math/camera_matrix.h"
+#include "core/templates/paged_allocator.h"
 #include "core/templates/rid_owner.h"
 #include "core/templates/self_list.h"
 #include "rasterizer_storage_gles3.h"
@@ -44,13 +45,47 @@
 #include "shader_gles3.h"
 #include "shaders/sky.glsl.gen.h"
 
-// Copied from renderer_scene_render_rd
+enum RenderListType {
+	RENDER_LIST_OPAQUE, //used for opaque objects
+	RENDER_LIST_ALPHA, //used for transparent objects
+	RENDER_LIST_SECONDARY, //used for shadows and other objects
+	RENDER_LIST_MAX
+};
+
+enum PassMode {
+	PASS_MODE_COLOR,
+	PASS_MODE_COLOR_TRANSPARENT,
+	PASS_MODE_COLOR_ADDITIVE,
+	PASS_MODE_SHADOW,
+	PASS_MODE_DEPTH,
+};
+
+// These should share as much as possible with SkyUniform Location
+enum SceneUniformLocation {
+	SCENE_TONEMAP_UNIFORM_LOCATION,
+	SCENE_GLOBALS_UNIFORM_LOCATION,
+	SCENE_DATA_UNIFORM_LOCATION,
+	SCENE_MATERIAL_UNIFORM_LOCATION,
+	SCENE_RADIANCE_UNIFORM_LOCATION,
+	SCENE_OMNILIGHT_UNIFORM_LOCATION,
+	SCENE_SPOTLIGHT_UNIFORM_LOCATION,
+};
+
+enum SkyUniformLocation {
+	SKY_TONEMAP_UNIFORM_LOCATION,
+	SKY_GLOBALS_UNIFORM_LOCATION,
+	SKY_SCENE_DATA_UNIFORM_LOCATION,
+	SKY_DIRECTIONAL_LIGHT_UNIFORM_LOCATION,
+	SKY_MATERIAL_UNIFORM_LOCATION,
+};
+
 struct RenderDataGLES3 {
 	RID render_buffers = RID();
+	bool transparent_bg = false;
 
 	Transform3D cam_transform = Transform3D();
 	CameraMatrix cam_projection = CameraMatrix();
-	bool cam_ortogonal = false;
+	bool cam_orthogonal = false;
 
 	// For stereo rendering
 	uint32_t view_count = 1;
@@ -110,6 +145,305 @@ private:
 		RID default_shader;
 	} scene_globals;
 
+	struct SceneState {
+		struct UBO {
+			float projection_matrix[16];
+			float inv_projection_matrix[16];
+			float inv_view_matrix[16];
+			float view_matrix[16];
+
+			float viewport_size[2];
+			float screen_pixel_size[2];
+
+			float ambient_light_color_energy[4];
+
+			float ambient_color_sky_mix;
+			uint32_t ambient_flags;
+			uint32_t material_uv2_mode;
+			float opaque_prepass_threshold;
+			//bool use_ambient_light;
+			//bool use_ambient_cubemap;
+			//bool use_reflection_cubemap;
+
+			float radiance_inverse_xform[12];
+
+			uint32_t directional_light_count;
+			float z_far;
+			float z_near;
+			uint32_t pancake_shadows;
+
+			uint32_t fog_enabled;
+			float fog_density;
+			float fog_height;
+			float fog_height_density;
+
+			float fog_light_color[3];
+			float fog_sun_scatter;
+
+			float fog_aerial_perspective;
+			float time;
+			uint32_t pad[2];
+		};
+		static_assert(sizeof(UBO) % 16 == 0, "Scene UBO size must be a multiple of 16 bytes");
+
+		struct TonemapUBO {
+			float exposure = 1.0;
+			float white = 1.0;
+			int32_t tonemapper = 0;
+			int32_t pad = 0;
+		};
+		static_assert(sizeof(TonemapUBO) % 16 == 0, "Tonemap UBO size must be a multiple of 16 bytes");
+
+		UBO ubo;
+		GLuint ubo_buffer = 0;
+		GLuint tonemap_buffer = 0;
+
+		bool used_depth_prepass = false;
+
+		GLES3::SceneShaderData::BlendMode current_blend_mode = GLES3::SceneShaderData::BLEND_MODE_MIX;
+		GLES3::SceneShaderData::DepthDraw current_depth_draw = GLES3::SceneShaderData::DEPTH_DRAW_OPAQUE;
+		GLES3::SceneShaderData::DepthTest current_depth_test = GLES3::SceneShaderData::DEPTH_TEST_DISABLED;
+		GLES3::SceneShaderData::Cull cull_mode = GLES3::SceneShaderData::CULL_BACK;
+
+		bool texscreen_copied = false;
+		bool used_screen_texture = false;
+		bool used_normal_texture = false;
+		bool used_depth_texture = false;
+	} scene_state;
+
+	struct GeometryInstanceGLES3;
+
+	// Cached data for drawing surfaces
+	struct GeometryInstanceSurface {
+		enum {
+			FLAG_PASS_DEPTH = 1,
+			FLAG_PASS_OPAQUE = 2,
+			FLAG_PASS_ALPHA = 4,
+			FLAG_PASS_SHADOW = 8,
+			FLAG_USES_SHARED_SHADOW_MATERIAL = 128,
+			FLAG_USES_SCREEN_TEXTURE = 2048,
+			FLAG_USES_DEPTH_TEXTURE = 4096,
+			FLAG_USES_NORMAL_TEXTURE = 8192,
+			FLAG_USES_DOUBLE_SIDED_SHADOWS = 16384,
+		};
+
+		union {
+			struct {
+				uint64_t lod_index : 8;
+				uint64_t surface_index : 8;
+				uint64_t geometry_id : 32;
+				uint64_t material_id_low : 16;
+
+				uint64_t material_id_hi : 16;
+				uint64_t shader_id : 32;
+				uint64_t uses_softshadow : 1;
+				uint64_t uses_projector : 1;
+				uint64_t uses_forward_gi : 1;
+				uint64_t uses_lightmap : 1;
+				uint64_t depth_layer : 4;
+				uint64_t priority : 8;
+			};
+			struct {
+				uint64_t sort_key1;
+				uint64_t sort_key2;
+			};
+		} sort;
+
+		RS::PrimitiveType primitive = RS::PRIMITIVE_MAX;
+		uint32_t flags = 0;
+		uint32_t surface_index = 0;
+		uint32_t lod_index = 0;
+
+		void *surface = nullptr;
+		GLES3::SceneShaderData *shader = nullptr;
+		GLES3::SceneMaterialData *material = nullptr;
+
+		void *surface_shadow = nullptr;
+		GLES3::SceneShaderData *shader_shadow = nullptr;
+		GLES3::SceneMaterialData *material_shadow = nullptr;
+
+		GeometryInstanceSurface *next = nullptr;
+		GeometryInstanceGLES3 *owner = nullptr;
+	};
+
+	struct GeometryInstanceGLES3 : public GeometryInstance {
+		//used during rendering
+		bool mirror = false;
+		bool non_uniform_scale = false;
+		float lod_bias = 0.0;
+		float lod_model_scale = 1.0;
+		AABB transformed_aabb; //needed for LOD
+		float depth = 0;
+		uint32_t flags_cache = 0;
+		bool store_transform_cache = true;
+		int32_t shader_parameters_offset = -1;
+
+		uint32_t layer_mask = 1;
+		uint32_t instance_count = 0;
+
+		RID mesh_instance;
+		bool can_sdfgi = false;
+		bool using_projectors = false;
+		bool using_softshadows = false;
+		bool fade_near = false;
+		float fade_near_begin = 0;
+		float fade_near_end = 0;
+		bool fade_far = false;
+		float fade_far_begin = 0;
+		float fade_far_end = 0;
+		float force_alpha = 1.0;
+		float parent_fade_alpha = 1.0;
+
+		uint32_t omni_light_count = 0;
+		uint32_t omni_lights[8];
+		uint32_t spot_light_count = 0;
+		uint32_t spot_lights[8];
+
+		//used during setup
+		uint32_t base_flags = 0;
+		Transform3D transform;
+		GeometryInstanceSurface *surface_caches = nullptr;
+		SelfList<GeometryInstanceGLES3> dirty_list_element;
+
+		struct Data {
+			//data used less often goes into regular heap
+			RID base;
+			RS::InstanceType base_type;
+
+			RID skeleton;
+			Vector<RID> surface_materials;
+			RID material_override;
+			RID material_overlay;
+			AABB aabb;
+
+			bool use_dynamic_gi = false;
+			bool use_baked_light = false;
+			bool cast_double_sided_shadows = false;
+			bool mirror = false;
+			bool dirty_dependencies = false;
+
+			RendererStorage::DependencyTracker dependency_tracker;
+		};
+
+		Data *data = nullptr;
+
+		GeometryInstanceGLES3() :
+				dirty_list_element(this) {}
+	};
+
+	enum {
+		INSTANCE_DATA_FLAGS_NON_UNIFORM_SCALE = 1 << 5,
+		INSTANCE_DATA_FLAG_USE_GI_BUFFERS = 1 << 6,
+		INSTANCE_DATA_FLAG_USE_LIGHTMAP_CAPTURE = 1 << 8,
+		INSTANCE_DATA_FLAG_USE_LIGHTMAP = 1 << 9,
+		INSTANCE_DATA_FLAG_USE_SH_LIGHTMAP = 1 << 10,
+		INSTANCE_DATA_FLAG_USE_VOXEL_GI = 1 << 11,
+		INSTANCE_DATA_FLAG_MULTIMESH = 1 << 12,
+		INSTANCE_DATA_FLAG_MULTIMESH_FORMAT_2D = 1 << 13,
+		INSTANCE_DATA_FLAG_MULTIMESH_HAS_COLOR = 1 << 14,
+		INSTANCE_DATA_FLAG_MULTIMESH_HAS_CUSTOM_DATA = 1 << 15,
+	};
+
+	static void _geometry_instance_dependency_changed(RendererStorage::DependencyChangedNotification p_notification, RendererStorage::DependencyTracker *p_tracker);
+	static void _geometry_instance_dependency_deleted(const RID &p_dependency, RendererStorage::DependencyTracker *p_tracker);
+
+	SelfList<GeometryInstanceGLES3>::List geometry_instance_dirty_list;
+
+	// Use PagedAllocator instead of RID to maximize performance
+	PagedAllocator<GeometryInstanceGLES3> geometry_instance_alloc;
+	PagedAllocator<GeometryInstanceSurface> geometry_instance_surface_alloc;
+
+	void _geometry_instance_add_surface_with_material(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, GLES3::SceneMaterialData *p_material, uint32_t p_material_id, uint32_t p_shader_id, RID p_mesh);
+	void _geometry_instance_add_surface_with_material_chain(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, GLES3::SceneMaterialData *p_material, RID p_mat_src, RID p_mesh);
+	void _geometry_instance_add_surface(GeometryInstanceGLES3 *ginstance, uint32_t p_surface, RID p_material, RID p_mesh);
+	void _geometry_instance_mark_dirty(GeometryInstance *p_geometry_instance);
+	void _geometry_instance_update(GeometryInstance *p_geometry_instance);
+	void _update_dirty_geometry_instances();
+
+	struct RenderListParameters {
+		GeometryInstanceSurface **elements = nullptr;
+		int element_count = 0;
+		bool reverse_cull = false;
+		uint32_t spec_constant_base_flags = 0;
+		bool force_wireframe = false;
+		Plane lod_plane;
+		float lod_distance_multiplier = 0.0;
+		float screen_mesh_lod_threshold = 0.0;
+
+		RenderListParameters(GeometryInstanceSurface **p_elements, int p_element_count, bool p_reverse_cull, uint32_t p_spec_constant_base_flags, bool p_force_wireframe = false, const Plane &p_lod_plane = Plane(), float p_lod_distance_multiplier = 0.0, float p_screen_mesh_lod_threshold = 0.0) {
+			elements = p_elements;
+			element_count = p_element_count;
+			reverse_cull = p_reverse_cull;
+			spec_constant_base_flags = p_spec_constant_base_flags;
+			force_wireframe = p_force_wireframe;
+			lod_plane = p_lod_plane;
+			lod_distance_multiplier = p_lod_distance_multiplier;
+			screen_mesh_lod_threshold = p_screen_mesh_lod_threshold;
+		}
+	};
+
+	struct RenderList {
+		LocalVector<GeometryInstanceSurface *> elements;
+
+		void clear() {
+			elements.clear();
+		}
+
+		//should eventually be replaced by radix
+
+		struct SortByKey {
+			_FORCE_INLINE_ bool operator()(const GeometryInstanceSurface *A, const GeometryInstanceSurface *B) const {
+				return (A->sort.sort_key2 == B->sort.sort_key2) ? (A->sort.sort_key1 < B->sort.sort_key1) : (A->sort.sort_key2 < B->sort.sort_key2);
+			}
+		};
+
+		void sort_by_key() {
+			SortArray<GeometryInstanceSurface *, SortByKey> sorter;
+			sorter.sort(elements.ptr(), elements.size());
+		}
+
+		void sort_by_key_range(uint32_t p_from, uint32_t p_size) {
+			SortArray<GeometryInstanceSurface *, SortByKey> sorter;
+			sorter.sort(elements.ptr() + p_from, p_size);
+		}
+
+		struct SortByDepth {
+			_FORCE_INLINE_ bool operator()(const GeometryInstanceSurface *A, const GeometryInstanceSurface *B) const {
+				return (A->owner->depth < B->owner->depth);
+			}
+		};
+
+		void sort_by_depth() { //used for shadows
+
+			SortArray<GeometryInstanceSurface *, SortByDepth> sorter;
+			sorter.sort(elements.ptr(), elements.size());
+		}
+
+		struct SortByReverseDepthAndPriority {
+			_FORCE_INLINE_ bool operator()(const GeometryInstanceSurface *A, const GeometryInstanceSurface *B) const {
+				return (A->sort.priority == B->sort.priority) ? (A->owner->depth > B->owner->depth) : (A->sort.priority < B->sort.priority);
+			}
+		};
+
+		void sort_by_reverse_depth_and_priority() { //used for alpha
+
+			SortArray<GeometryInstanceSurface *, SortByReverseDepthAndPriority> sorter;
+			sorter.sort(elements.ptr(), elements.size());
+		}
+
+		_FORCE_INLINE_ void add_element(GeometryInstanceSurface *p_element) {
+			elements.push_back(p_element);
+		}
+	};
+
+	RenderList render_list[RENDER_LIST_MAX];
+
+	void _setup_environment(const RenderDataGLES3 *p_render_data, bool p_no_fog, const Size2i &p_screen_size, bool p_flip_y, const Color &p_default_bg_color, bool p_pancake_shadows);
+	void _fill_render_list(RenderListType p_render_list, const RenderDataGLES3 *p_render_data, PassMode p_pass_mode, bool p_append = false);
+
+	template <PassMode p_pass_mode>
+	_FORCE_INLINE_ void _render_list_template(RenderListParameters *p_params, const RenderDataGLES3 *p_render_data, uint32_t p_from_element, uint32_t p_to_element, bool p_alpha_pass = false);
+
 protected:
 	double time;
 	double time_step = 0;
@@ -125,6 +459,8 @@ protected:
 		//bool use_debanding = false;
 		//uint32_t view_count = 1;
 
+		bool is_transparent = false;
+
 		RID render_target;
 		GLuint internal_texture = 0; // Used for rendering when post effects are enabled
 		GLuint depth_texture = 0; // Main depth texture
@@ -391,9 +727,15 @@ public:
 	/* SDFGI UPDATE */
 
 	void sdfgi_update(RID p_render_buffers, RID p_environment, const Vector3 &p_world_position) override {}
-	int sdfgi_get_pending_region_count(RID p_render_buffers) const override { return 0; }
-	AABB sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const override { return AABB(); }
-	uint32_t sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const override { return 0; }
+	int sdfgi_get_pending_region_count(RID p_render_buffers) const override {
+		return 0;
+	}
+	AABB sdfgi_get_pending_region_bounds(RID p_render_buffers, int p_region) const override {
+		return AABB();
+	}
+	uint32_t sdfgi_get_pending_region_cascade(RID p_render_buffers, int p_region) const override {
+		return 0;
+	}
 
 	/* SKY API */
 
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp
index 0d15e44702..3c28289bd0 100644
--- a/drivers/gles3/rasterizer_storage_gles3.cpp
+++ b/drivers/gles3/rasterizer_storage_gles3.cpp
@@ -344,9 +344,10 @@ void RasterizerStorageGLES3::canvas_light_occluder_set_polylines(RID p_occluder,
 RS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
 	if (GLES3::MeshStorage::get_singleton()->owns_mesh(p_rid)) {
 		return RS::INSTANCE_MESH;
-	}
-	if (GLES3::MeshStorage::get_singleton()->owns_multimesh(p_rid)) {
+	} else if (GLES3::MeshStorage::get_singleton()->owns_multimesh(p_rid)) {
 		return RS::INSTANCE_MULTIMESH;
+	} else if (GLES3::LightStorage::get_singleton()->owns_light(p_rid)) {
+		return RS::INSTANCE_LIGHT;
 	}
 	return RS::INSTANCE_NONE;
 }
@@ -376,19 +377,14 @@ bool RasterizerStorageGLES3::free(RID p_rid) {
 	} else if (GLES3::MeshStorage::get_singleton()->owns_mesh_instance(p_rid)) {
 		GLES3::MeshStorage::get_singleton()->mesh_instance_free(p_rid);
 		return true;
+	} else if (GLES3::LightStorage::get_singleton()->owns_light(p_rid)) {
+		GLES3::LightStorage::get_singleton()->light_free(p_rid);
+		return true;
 	} else {
 		return false;
 	}
 	/*
-	} else if (light_owner.owns(p_rid)) {
-		Light *light = light_owner.get_or_null(p_rid);
-		light->instance_remove_deps();
-
-		light_owner.free(p_rid);
-		memdelete(light);
-
-		return true;
-	} else if (reflection_probe_owner.owns(p_rid)) {
+	  else if (reflection_probe_owner.owns(p_rid)) {
 		// delete the texture
 		ReflectionProbe *reflection_probe = reflection_probe_owner.get_or_null(p_rid);
 		reflection_probe->instance_remove_deps();
diff --git a/drivers/gles3/rasterizer_storage_gles3.h b/drivers/gles3/rasterizer_storage_gles3.h
index d22db198c8..fa74fbd5f6 100644
--- a/drivers/gles3/rasterizer_storage_gles3.h
+++ b/drivers/gles3/rasterizer_storage_gles3.h
@@ -41,6 +41,7 @@
 #include "servers/rendering/shader_compiler.h"
 #include "servers/rendering/shader_language.h"
 #include "storage/config.h"
+#include "storage/light_storage.h"
 #include "storage/material_storage.h"
 #include "storage/mesh_storage.h"
 #include "storage/texture_storage.h"
@@ -55,6 +56,48 @@ public:
 
 	GLES3::Config *config = nullptr;
 
+	static _FORCE_INLINE_ void store_transform(const Transform3D &p_mtx, float *p_array) {
+		p_array[0] = p_mtx.basis.rows[0][0];
+		p_array[1] = p_mtx.basis.rows[1][0];
+		p_array[2] = p_mtx.basis.rows[2][0];
+		p_array[3] = 0;
+		p_array[4] = p_mtx.basis.rows[0][1];
+		p_array[5] = p_mtx.basis.rows[1][1];
+		p_array[6] = p_mtx.basis.rows[2][1];
+		p_array[7] = 0;
+		p_array[8] = p_mtx.basis.rows[0][2];
+		p_array[9] = p_mtx.basis.rows[1][2];
+		p_array[10] = p_mtx.basis.rows[2][2];
+		p_array[11] = 0;
+		p_array[12] = p_mtx.origin.x;
+		p_array[13] = p_mtx.origin.y;
+		p_array[14] = p_mtx.origin.z;
+		p_array[15] = 1;
+	}
+
+	static _FORCE_INLINE_ void store_transform_3x3(const Basis &p_mtx, float *p_array) {
+		p_array[0] = p_mtx.rows[0][0];
+		p_array[1] = p_mtx.rows[1][0];
+		p_array[2] = p_mtx.rows[2][0];
+		p_array[3] = 0;
+		p_array[4] = p_mtx.rows[0][1];
+		p_array[5] = p_mtx.rows[1][1];
+		p_array[6] = p_mtx.rows[2][1];
+		p_array[7] = 0;
+		p_array[8] = p_mtx.rows[0][2];
+		p_array[9] = p_mtx.rows[1][2];
+		p_array[10] = p_mtx.rows[2][2];
+		p_array[11] = 0;
+	}
+
+	static _FORCE_INLINE_ void store_camera(const CameraMatrix &p_mtx, float *p_array) {
+		for (int i = 0; i < 4; i++) {
+			for (int j = 0; j < 4; j++) {
+				p_array[i * 4 + j] = p_mtx.matrix[i][j];
+			}
+		}
+	}
+
 	struct Resources {
 		GLuint mipmap_blur_fbo;
 		GLuint mipmap_blur_color;
diff --git a/drivers/gles3/shader_gles3.cpp b/drivers/gles3/shader_gles3.cpp
index e356fa8c1f..b3f37207da 100644
--- a/drivers/gles3/shader_gles3.cpp
+++ b/drivers/gles3/shader_gles3.cpp
@@ -171,6 +171,15 @@ void ShaderGLES3::_build_variant_code(StringBuilder &builder, uint32_t p_variant
 	}
 	builder.append("\n"); //make sure defines begin at newline
 
+	// Default to highp precision unless specified otherwise.
+	builder.append("precision highp float;\n");
+	builder.append("precision highp int;\n");
+#ifndef GLES_OVER_GL
+	builder.append("precision highp sampler2D;\n");
+	builder.append("precision highp samplerCube;\n");
+	builder.append("precision highp sampler2DArray;\n");
+#endif
+
 	for (uint32_t i = 0; i < p_template.chunks.size(); i++) {
 		const StageTemplate::Chunk &chunk = p_template.chunks[i];
 		switch (chunk.type) {
diff --git a/drivers/gles3/shader_gles3.h b/drivers/gles3/shader_gles3.h
index 8d1b142dc6..763d3bfa8b 100644
--- a/drivers/gles3/shader_gles3.h
+++ b/drivers/gles3/shader_gles3.h
@@ -218,6 +218,7 @@ protected:
 		ERR_FAIL_INDEX_V(p_which, uniform_count, -1);
 		Version *version = version_owner.get_or_null(p_version);
 		ERR_FAIL_COND_V(!version, -1);
+		ERR_FAIL_INDEX_V(p_variant, int(version->variants.size()), -1);
 		return version->variants[p_variant].lookup_ptr(p_specialization)->uniform_location[p_which];
 	}
 
diff --git a/drivers/gles3/shaders/canvas.glsl b/drivers/gles3/shaders/canvas.glsl
index f121679833..381a0e8a73 100644
--- a/drivers/gles3/shaders/canvas.glsl
+++ b/drivers/gles3/shaders/canvas.glsl
@@ -518,8 +518,8 @@ void main() {
 		float px_size = max(0.5 * dot((vec2(px_range) / msdf_size), dest_size), 1.0);
 		float d = msdf_median(msdf_sample.r, msdf_sample.g, msdf_sample.b, msdf_sample.a) - 0.5;
 
-		if (outline_thickness > 0) {
-			float cr = clamp(outline_thickness, 0.0, px_range / 2) / px_range;
+		if (outline_thickness > 0.0) {
+			float cr = clamp(outline_thickness, 0.0, px_range / 2.0) / px_range;
 			float a = clamp((d + cr) * px_size, 0.0, 1.0);
 			color.a = a * color.a;
 		} else {
@@ -710,8 +710,8 @@ void main() {
 			vec2 pos_rot = pos_norm * mat2(vec2(0.7071067811865476, -0.7071067811865476), vec2(0.7071067811865476, 0.7071067811865476)); //is there a faster way to 45 degrees rot?
 			float tex_ofs;
 			float distance;
-			if (pos_rot.y > 0) {
-				if (pos_rot.x > 0) {
+			if (pos_rot.y > 0.0) {
+				if (pos_rot.x > 0.0) {
 					tex_ofs = pos_box.y * 0.125 + 0.125;
 					distance = shadow_pos.x;
 				} else {
@@ -719,7 +719,7 @@ void main() {
 					distance = shadow_pos.y;
 				}
 			} else {
-				if (pos_rot.x < 0) {
+				if (pos_rot.x < 0.0) {
 					tex_ofs = pos_box.y * -0.125 + (0.5 + 0.125);
 					distance = -shadow_pos.x;
 				} else {
diff --git a/drivers/gles3/shaders/scene.glsl b/drivers/gles3/shaders/scene.glsl
index 16a9224fbb..ea28685be7 100644
--- a/drivers/gles3/shaders/scene.glsl
+++ b/drivers/gles3/shaders/scene.glsl
@@ -20,13 +20,19 @@ USE_LIGHT_POSITIONAL = false
 
 #include "stdlib_inc.glsl"
 
+#if !defined(MODE_RENDER_DEPTH) || defined(TANGENT_USED) || defined(NORMAL_MAP_USED) || defined(LIGHT_ANISOTROPY_USED) ||defined(LIGHT_CLEARCOAT_USED)
+#ifndef NORMAL_USED
+#define NORMAL_USED
+#endif
+#endif
+
 /*
 from RenderingServer:
 ARRAY_VERTEX = 0, // RG32F or RGB32F (depending on 2D bit)
+ARRAY_NORMAL = 1, // A2B10G10R10, A is ignored.
+ARRAY_TANGENT = 2, // A2B10G10R10, A flips sign of binormal.
 ARRAY_COLOR = 3, // RGBA8
 ARRAY_TEX_UV = 4, // RG32F
-ARRAY_TANGENT = 2, // A2B10G10R10, A flips sign of binormal.
-ARRAY_NORMAL = 1, // A2B10G10R10, A is ignored.
 ARRAY_TEX_UV2 = 5, // RG32F
 ARRAY_CUSTOM0 = 6, // Depends on ArrayCustomFormat.
 ARRAY_CUSTOM1 = 7,
@@ -40,7 +46,7 @@ ARRAY_MAX = 13
 
 /* INPUT ATTRIBS */
 
-layout(location = 0) in vec3 vertex_attrib;
+layout(location = 0) in highp vec3 vertex_attrib;
 /* clang-format on */
 
 #ifdef NORMAL_USED
@@ -79,19 +85,23 @@ layout(location = 8) in vec4 custom2_attrib;
 layout(location = 9) in vec4 custom3_attrib;
 #endif
 
-#if defined(BONES_USED) || defined(USE_PARTICLE_TRAILS)
+#if defined(BONES_USED)
 layout(location = 10) in uvec4 bone_attrib;
 #endif
 
-#if defined(WEIGHTS_USED) || defined(USE_PARTICLE_TRAILS)
+#if defined(WEIGHTS_USED)
 layout(location = 11) in vec4 weight_attrib;
 #endif
 
-layout(std140) uniform SceneData { // ubo:3
-	mat4 projection_matrix;
-	mat4 inv_projection_matrix;
-	mat4 inv_view_matrix;
-	mat4 view_matrix;
+layout(std140) uniform GlobalVariableData { //ubo:1
+	vec4 global_variables[MAX_GLOBAL_VARIABLES];
+};
+
+layout(std140) uniform SceneData { // ubo:2
+	highp mat4 projection_matrix;
+	highp mat4 inv_projection_matrix;
+	highp mat4 inv_view_matrix;
+	highp mat4 view_matrix;
 
 	vec2 viewport_size;
 	vec2 screen_pixel_size;
@@ -143,15 +153,15 @@ out highp vec3 vertex_interp;
 out vec3 normal_interp;
 #endif
 
-#if defined(ENABLE_COLOR_INTERP)
+#if defined(COLOR_USED)
 out vec4 color_interp;
 #endif
 
-#if defined(ENABLE_UV_INTERP)
+#if defined(UV_USED)
 out vec2 uv_interp;
 #endif
 
-#if defined(ENABLE_UV2_INTERP)
+#if defined(UV2_USED)
 out vec2 uv2_interp;
 #else
 #ifdef USE_LIGHTMAP
@@ -159,15 +169,15 @@ out vec2 uv2_interp;
 #endif
 #endif
 
-#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+#if defined(TANGENT_USED) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
 out vec3 tangent_interp;
 out vec3 binormal_interp;
 #endif
 
-#if defined(USE_MATERIAL)
+#if defined(MATERIAL_UNIFORMS_USED)
 
 /* clang-format off */
-layout(std140) uniform UniformData { // ubo:1
+layout(std140) uniform MaterialUniforms { // ubo:3
 
 #MATERIAL_UNIFORMS
 
@@ -194,31 +204,31 @@ void main() {
 #ifdef NORMAL_USED
 	vec3 normal = normal_attrib * 2.0 - 1.0;
 #endif
-	mat3 model_normal_matrix = mat3(model_matrix);
+	highp mat3 model_normal_matrix = mat3(model_matrix);
 
-#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+#if defined(TANGENT_USED) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
 	vec3 tangent;
 	float binormalf;
 	tangent = normal_tangent_attrib.xyz;
 	binormalf = normal_tangent_attrib.a;
 #endif
 
-#if defined(ENABLE_COLOR_INTERP)
+#if defined(COLOR_USED)
 	color_interp = color_attrib;
 #endif
 
-#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+#if defined(TANGENT_USED) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
 	vec3 binormal = normalize(cross(normal, tangent) * binormalf);
 #endif
 
-#if defined(ENABLE_UV_INTERP)
+#if defined(UV_USED)
 	uv_interp = uv_attrib;
 #endif
 
 #ifdef USE_LIGHTMAP
 	uv2_interp = lightmap_uv_rect.zw * uv2_attrib + lightmap_uv_rect.xy;
 #else
-#if defined(ENABLE_UV2_INTERP)
+#if defined(UV2_USED)
 	uv2_interp = uv2_attrib;
 #endif
 #endif
@@ -226,8 +236,8 @@ void main() {
 #if defined(OVERRIDE_POSITION)
 	highp vec4 position;
 #endif
-	mat4 projection_matrix = scene_data.projection_matrix;
-	mat4 inv_projection_matrix = scene_data.inv_projection_matrix;
+	highp mat4 projection_matrix = scene_data.projection_matrix;
+	highp mat4 inv_projection_matrix = scene_data.inv_projection_matrix;
 
 	vec4 instance_custom = vec4(0.0);
 
@@ -250,8 +260,8 @@ void main() {
 
 	float roughness = 1.0;
 
-	mat4 modelview = scene_data.view_matrix * model_matrix;
-	mat3 modelview_normal = mat3(scene_data.view_matrix) * model_normal_matrix;
+	highp mat4 modelview = scene_data.view_matrix * model_matrix;
+	highp mat3 modelview_normal = mat3(scene_data.view_matrix) * model_normal_matrix;
 
 	float point_size = 1.0;
 
@@ -296,7 +306,7 @@ void main() {
 	normal_interp = normal;
 #endif
 
-#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+#if defined(TANGENT_USED) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
 	tangent_interp = tangent;
 	binormal_interp = binormal;
 #endif
@@ -327,7 +337,7 @@ void main() {
 #define SPECULAR_SCHLICK_GGX
 #endif
 
-#if !defined(MODE_RENDER_DEPTH) || defined(TANGENT_USED) || defined(NORMAL_MAP_USED) || defined(LIGHT_ANISOTROPY_USED)
+#if !defined(MODE_RENDER_DEPTH) || defined(TANGENT_USED) || defined(NORMAL_MAP_USED) || defined(LIGHT_ANISOTROPY_USED) ||defined(LIGHT_CLEARCOAT_USED)
 #ifndef NORMAL_USED
 #define NORMAL_USED
 #endif
@@ -351,19 +361,19 @@ uniform highp mat4 world_transform;
 /* clang-format on */
 
 #define M_PI 3.14159265359
-#define SHADER_IS_SRGB false
+#define SHADER_IS_SRGB true
 
 /* Varyings */
 
-#if defined(ENABLE_COLOR_INTERP)
+#if defined(COLOR_USED)
 in vec4 color_interp;
 #endif
 
-#if defined(ENABLE_UV_INTERP)
+#if defined(UV_USED)
 in vec2 uv_interp;
 #endif
 
-#if defined(ENABLE_UV2_INTERP)
+#if defined(UV2_USED)
 in vec2 uv2_interp;
 #else
 #ifdef USE_LIGHTMAP
@@ -371,19 +381,22 @@ in vec2 uv2_interp;
 #endif
 #endif
 
-#if defined(ENABLE_TANGENT_INTERP) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
+#if defined(TANGENT_USED) || defined(ENABLE_NORMALMAP) || defined(LIGHT_USE_ANISOTROPY)
 in vec3 tangent_interp;
 in vec3 binormal_interp;
 #endif
 
-in highp vec3 vertex_interp;
+#ifdef NORMAL_USED
 in vec3 normal_interp;
+#endif
+
+in highp vec3 vertex_interp;
 
 /* PBR CHANNELS */
 
 #ifdef USE_RADIANCE_MAP
 
-layout(std140) uniform Radiance { // ubo:2
+layout(std140) uniform Radiance { // ubo:4
 
 	mat4 radiance_inverse_xform;
 	float radiance_ambient_contribution;
@@ -405,12 +418,16 @@ vec3 textureDualParaboloid(sampler2D p_tex, vec3 p_vec, float p_roughness) {
 
 #endif
 
-/* Material Uniforms */
+layout(std140) uniform GlobalVariableData { //ubo:1
+	vec4 global_variables[MAX_GLOBAL_VARIABLES];
+};
+
+	/* Material Uniforms */
 
-#if defined(USE_MATERIAL)
+#if defined(MATERIAL_UNIFORMS_USED)
 
 /* clang-format off */
-layout(std140) uniform UniformData {
+layout(std140) uniform MaterialUniforms { // ubo:3
 
 #MATERIAL_UNIFORMS
 
@@ -419,11 +436,11 @@ layout(std140) uniform UniformData {
 
 #endif
 
-layout(std140) uniform SceneData { // ubo:3
-	mat4 projection_matrix;
-	mat4 inv_projection_matrix;
-	mat4 inv_view_matrix;
-	mat4 view_matrix;
+layout(std140) uniform SceneData { // ubo:2
+	highp mat4 projection_matrix;
+	highp mat4 inv_projection_matrix;
+	highp mat4 inv_view_matrix;
+	highp mat4 view_matrix;
 
 	vec2 viewport_size;
 	vec2 screen_pixel_size;
@@ -501,12 +518,12 @@ struct LightData { //this structure needs to be as packed as possible
 	bool shadow_enabled;
 };
 
-layout(std140) uniform OmniLightData { // ubo:4
+layout(std140) uniform OmniLightData { // ubo:5
 
 	LightData omni_lights[MAX_LIGHT_DATA_STRUCTS];
 };
 
-layout(std140) uniform SpotLightData { // ubo:5
+layout(std140) uniform SpotLightData { // ubo:6
 
 	LightData spot_lights[MAX_LIGHT_DATA_STRUCTS];
 };
diff --git a/drivers/gles3/shaders/sky.glsl b/drivers/gles3/shaders/sky.glsl
index a8e5daafa1..3a1bcd3b28 100644
--- a/drivers/gles3/shaders/sky.glsl
+++ b/drivers/gles3/shaders/sky.glsl
@@ -12,23 +12,14 @@ mode_cubemap_quarter_res = #define USE_CUBEMAP_PASS \n#define USE_QUARTER_RES_PA
 
 #[vertex]
 
-#ifdef USE_GLES_OVER_GL
-#define lowp
-#define mediump
-#define highp
-#else
-precision highp float;
-precision highp int;
-#endif
-
 out vec2 uv_interp;
 /* clang-format on */
 
 void main() {
 	// One big triangle to cover the whole screen
-	vec2 base_arr[3] = vec2[](vec2(-1.0, -1.0), vec2(-1.0, 3.0), vec2(3.0, -1.0));
+	vec2 base_arr[3] = vec2[](vec2(-1.0, -1.0), vec2(3.0, -1.0), vec2(-1.0, 3.0));
 	uv_interp = base_arr[gl_VertexID];
-	gl_Position = vec4(uv_interp, 0.0, 1.0);
+	gl_Position = vec4(uv_interp, 1.0, 1.0);
 }
 
 /* clang-format off */
@@ -36,20 +27,6 @@ void main() {
 
 #define M_PI 3.14159265359
 
-#ifdef USE_GLES_OVER_GL
-#define lowp
-#define mediump
-#define highp
-#else
-#if defined(USE_HIGHP_PRECISION)
-precision highp float;
-precision highp int;
-#else
-precision mediump float;
-precision mediump int;
-#endif
-#endif
-
 #include "tonemap_inc.glsl"
 
 in vec2 uv_interp;
@@ -65,22 +42,22 @@ uniform sampler2D half_res; //texunit:-2
 uniform sampler2D quarter_res; //texunit:-3
 #endif
 
-layout(std140) uniform SceneData { //ubo:0
-	float pad1;
-	float pad2;
-};
-
 layout(std140) uniform GlobalVariableData { //ubo:1
 	vec4 global_variables[MAX_GLOBAL_VARIABLES];
 };
 
+layout(std140) uniform SceneData { //ubo:2
+	float pad1;
+	float pad2;
+};
+
 struct DirectionalLightData {
 	vec4 direction_energy;
 	vec4 color_size;
 	bool enabled;
 };
 
-layout(std140) uniform DirectionalLights { //ubo:2
+layout(std140) uniform DirectionalLights { //ubo:3
 	DirectionalLightData data[MAX_DIRECTIONAL_LIGHT_DATA_STRUCTS];
 }
 directional_lights;
@@ -88,7 +65,7 @@ directional_lights;
 /* clang-format off */
 
 #ifdef MATERIAL_UNIFORMS_USED
-layout(std140) uniform MaterialUniforms{ //ubo:3
+layout(std140) uniform MaterialUniforms{ //ubo:4
 
 #MATERIAL_UNIFORMS
 
diff --git a/drivers/gles3/shaders/stdlib_inc.glsl b/drivers/gles3/shaders/stdlib_inc.glsl
index 3d976e9ab8..6cce6c12bd 100644
--- a/drivers/gles3/shaders/stdlib_inc.glsl
+++ b/drivers/gles3/shaders/stdlib_inc.glsl
@@ -1,5 +1,6 @@
 
 #ifdef USE_GLES_OVER_GL
+// Floating point pack/unpack functions are part of the GLSL ES 300 specification used by web and mobile.
 uint float2half(uint f) {
 	return ((f >> uint(16)) & uint(0x8000)) |
 			((((f & uint(0x7f800000)) - uint(0x38000000)) >> uint(13)) & uint(0x7c00)) |
@@ -37,6 +38,7 @@ vec2 unpackSnorm2x16(uint p) {
 	vec2 v = vec2(float(p & uint(0xffff)), float(p >> uint(16)));
 	return clamp((v - 32767.0) * vec2(0.00003051851), vec2(-1.0), vec2(1.0));
 }
+#endif
 
 uint packUnorm4x8(vec4 v) {
 	uvec4 uv = uvec4(round(clamp(v, vec4(0.0), vec4(1.0)) * 255.0));
@@ -56,4 +58,3 @@ vec4 unpackSnorm4x8(uint p) {
 	vec4 v = vec4(float(p & uint(0xffff)), float((p >> uint(8)) & uint(0xffff)), float((p >> uint(16)) & uint(0xffff)), float(p >> uint(24)));
 	return clamp((v - vec4(127.0)) * vec4(0.00787401574), vec4(-1.0), vec4(1.0));
 }
-#endif
diff --git a/drivers/gles3/shaders/tonemap_inc.glsl b/drivers/gles3/shaders/tonemap_inc.glsl
index b993f5d97b..ea15c05359 100644
--- a/drivers/gles3/shaders/tonemap_inc.glsl
+++ b/drivers/gles3/shaders/tonemap_inc.glsl
@@ -10,10 +10,12 @@ uniform sampler3D source_color_correction; //texunit:-1
 #endif
 #endif
 
-// These could be grouped into some form of SceneData UBO along with time, will have to test performance though
-uniform int tonemapper;
-uniform float exposure;
-uniform float white;
+layout(std140) uniform TonemapData { //ubo:0
+	float exposure;
+	float white;
+	int tonemapper;
+	int pad;
+};
 
 vec3 apply_bcs(vec3 color, vec3 bcs) {
 	color = mix(vec3(0.0), color, bcs.x);
diff --git a/drivers/gles3/storage/config.cpp b/drivers/gles3/storage/config.cpp
index 369e523cc4..7280868564 100644
--- a/drivers/gles3/storage/config.cpp
+++ b/drivers/gles3/storage/config.cpp
@@ -120,16 +120,6 @@ Config::Config() {
 	support_write_depth = extensions.has("GL_EXT_frag_depth");
 #endif
 
-	support_half_float_vertices = true;
-//every platform should support this except web, iOS has issues with their support, so add option to disable
-#ifdef JAVASCRIPT_ENABLED
-	support_half_float_vertices = false;
-#endif
-	bool disable_half_float = false; //GLOBAL_GET("rendering/opengl/compatibility/disable_half_float");
-	if (disable_half_float) {
-		support_half_float_vertices = false;
-	}
-
 	//picky requirements for these
 	support_shadow_cubemaps = support_write_depth && support_depth_cubemaps;
 	// the use skeleton software path should be used if either float texture is not supported,
@@ -149,6 +139,27 @@ Config::Config() {
 
 	force_vertex_shading = false; //GLOBAL_GET("rendering/quality/shading/force_vertex_shading");
 	use_nearest_mip_filter = GLOBAL_GET("rendering/textures/default_filters/use_nearest_mipmap_filter");
+
+	use_depth_prepass = bool(GLOBAL_GET("rendering/driver/depth_prepass/enable"));
+	if (use_depth_prepass) {
+		String vendors = GLOBAL_GET("rendering/driver/depth_prepass/disable_for_vendors");
+		Vector<String> vendor_match = vendors.split(",");
+		String renderer = (const char *)glGetString(GL_RENDERER);
+		for (int i = 0; i < vendor_match.size(); i++) {
+			String v = vendor_match[i].strip_edges();
+			if (v == String()) {
+				continue;
+			}
+
+			if (renderer.findn(v) != -1) {
+				use_depth_prepass = false;
+			}
+		}
+	}
+
+	max_renderable_elements = GLOBAL_GET("rendering/limits/opengl/max_renderable_elements");
+	max_renderable_lights = GLOBAL_GET("rendering/limits/opengl/max_renderable_lights");
+	max_lights_per_object = GLOBAL_GET("rendering/limits/opengl/max_lights_per_object");
 }
 
 Config::~Config() {
diff --git a/drivers/gles3/storage/config.h b/drivers/gles3/storage/config.h
index 0646881b72..7e143c1c1e 100644
--- a/drivers/gles3/storage/config.h
+++ b/drivers/gles3/storage/config.h
@@ -58,6 +58,9 @@ public:
 	int max_texture_image_units = 0;
 	int max_texture_size = 0;
 	int max_uniform_buffer_size = 0;
+	int max_renderable_elements = 0;
+	int max_renderable_lights = 0;
+	int max_lights_per_object = 0;
 
 	// TODO implement wireframe in OpenGL
 	// bool generate_wireframes;
@@ -82,7 +85,6 @@ public:
 
 	bool support_32_bits_indices = false;
 	bool support_write_depth = false;
-	bool support_half_float_vertices = false;
 	bool support_npot_repeat_mipmap = false;
 	bool support_depth_cubemaps = false;
 	bool support_shadow_cubemaps = false;
@@ -97,6 +99,8 @@ public:
 	// so the user can switch orphaning off for them.
 	bool should_orphan = true;
 
+	bool use_depth_prepass = true;
+
 	static Config *get_singleton() { return singleton; };
 
 	Config();
diff --git a/drivers/gles3/storage/material_storage.cpp b/drivers/gles3/storage/material_storage.cpp
index a3111da28a..6dff8a2a51 100644
--- a/drivers/gles3/storage/material_storage.cpp
+++ b/drivers/gles3/storage/material_storage.cpp
@@ -43,7 +43,7 @@ using namespace GLES3;
 ///////////////////////////////////////////////////////////////////////////
 // UBI helper functions
 
-_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, int p_array_size, const Variant &value, uint8_t *data, bool p_linear_color) {
+_FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataType type, int p_array_size, const Variant &value, uint8_t *data) {
 	switch (type) {
 		case ShaderLanguage::TYPE_BOOL: {
 			uint32_t *gui = (uint32_t *)data;
@@ -399,9 +399,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 					for (int i = 0, j = 0; i < p_array_size; i++, j += 4) {
 						if (i < s) {
 							Color color = a[i];
-							if (p_linear_color) {
-								color = color.srgb_to_linear();
-							}
 							gui[j] = color.r;
 							gui[j + 1] = color.g;
 							gui[j + 2] = color.b;
@@ -433,10 +430,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 				if (value.get_type() == Variant::COLOR) {
 					Color v = value;
 
-					if (p_linear_color) {
-						v = v.srgb_to_linear();
-					}
-
 					gui[0] = v.r;
 					gui[1] = v.g;
 					gui[2] = v.b;
@@ -459,9 +452,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 					for (int i = 0, j = 0; i < p_array_size; i++, j += 4) {
 						if (i < s) {
 							Color color = a[i];
-							if (p_linear_color) {
-								color = color.srgb_to_linear();
-							}
 							gui[j] = color.r;
 							gui[j + 1] = color.g;
 							gui[j + 2] = color.b;
@@ -496,10 +486,6 @@ _FORCE_INLINE_ static void _fill_std140_variant_ubo_value(ShaderLanguage::DataTy
 				if (value.get_type() == Variant::COLOR) {
 					Color v = value;
 
-					if (p_linear_color) {
-						v = v.srgb_to_linear();
-					}
-
 					gui[0] = v.r;
 					gui[1] = v.g;
 					gui[2] = v.b;
@@ -987,7 +973,7 @@ void MaterialData::update_uniform_buffer(const Map<StringName, ShaderLanguage::S
 
 		if (V) {
 			//user provided
-			_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, V->get(), data, p_use_linear_color);
+			_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, V->get(), data);
 
 		} else if (E.value.default_value.size()) {
 			//default value
@@ -997,7 +983,7 @@ void MaterialData::update_uniform_buffer(const Map<StringName, ShaderLanguage::S
 			//zero because it was not provided
 			if ((E.value.type == ShaderLanguage::TYPE_VEC3 || E.value.type == ShaderLanguage::TYPE_VEC4) && E.value.hint == ShaderLanguage::ShaderNode::Uniform::HINT_COLOR) {
 				//colors must be set as black, with alpha as 1.0
-				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data, p_use_linear_color);
+				_fill_std140_variant_ubo_value(E.value.type, E.value.array_size, Color(0, 0, 0, 1), data);
 			} else {
 				//else just zero it out
 				_fill_std140_ubo_empty(E.value.type, E.value.array_size, data);
@@ -1883,7 +1869,7 @@ void MaterialStorage::_global_variable_store_in_buffer(int32_t p_index, RS::Glob
 			bv.w = v.a;
 
 			GlobalVariables::Value &bv_linear = global_variables.buffer_values[p_index + 1];
-			v = v.srgb_to_linear();
+			//v = v.srgb_to_linear();
 			bv_linear.x = v.r;
 			bv_linear.y = v.g;
 			bv_linear.z = v.b;
@@ -2322,7 +2308,7 @@ void MaterialStorage::global_variables_instance_update(RID p_instance, int p_ind
 
 	pos += p_index;
 
-	_fill_std140_variant_ubo_value(datatype, 0, p_value, (uint8_t *)&global_variables.buffer_values[pos], true); //instances always use linear color in this renderer
+	_fill_std140_variant_ubo_value(datatype, 0, p_value, (uint8_t *)&global_variables.buffer_values[pos]);
 	_global_variable_mark_buffer_dirty(pos, 1);
 }
 
@@ -2929,7 +2915,7 @@ void CanvasMaterialData::update_parameters(const Map<StringName, Variant> &p_par
 
 void CanvasMaterialData::bind_uniforms() {
 	// Bind Material Uniforms
-	glBindBufferBase(GL_UNIFORM_BUFFER, RasterizerCanvasGLES3::MATERIAL_UNIFORM_BUFFER_OBJECT, uniform_buffer);
+	glBindBufferBase(GL_UNIFORM_BUFFER, RasterizerCanvasGLES3::MATERIAL_UNIFORM_LOCATION, uniform_buffer);
 
 	RID *textures = texture_cache.ptrw();
 	ShaderCompiler::GeneratedCode::Texture *texture_uniforms = shader_data->texture_uniforms.ptrw();
@@ -3162,7 +3148,7 @@ GLES3::MaterialData *GLES3::_create_sky_material_func(ShaderData *p_shader) {
 
 void SkyMaterialData::bind_uniforms() {
 	// Bind Material Uniforms
-	glBindBufferBase(GL_UNIFORM_BUFFER, 3, uniform_buffer);
+	glBindBufferBase(GL_UNIFORM_BUFFER, SKY_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
 
 	RID *textures = texture_cache.ptrw();
 	ShaderCompiler::GeneratedCode::Texture *texture_uniforms = shader_data->texture_uniforms.ptrw();
@@ -3278,6 +3264,18 @@ void SceneShaderData::set_code(const String &p_code) {
 	actions.write_flag_pointers["VERTEX"] = &uses_vertex;
 	actions.write_flag_pointers["POSITION"] = &uses_position;
 
+	actions.usage_flag_pointers["TANGENT"] = &uses_tangent;
+	actions.usage_flag_pointers["BINORMAL"] = &uses_tangent;
+	actions.usage_flag_pointers["COLOR"] = &uses_color;
+	actions.usage_flag_pointers["UV"] = &uses_uv;
+	actions.usage_flag_pointers["UV2"] = &uses_uv2;
+	actions.usage_flag_pointers["CUSTOM0"] = &uses_custom0;
+	actions.usage_flag_pointers["CUSTOM1"] = &uses_custom1;
+	actions.usage_flag_pointers["CUSTOM2"] = &uses_custom2;
+	actions.usage_flag_pointers["CUSTOM3"] = &uses_custom3;
+	actions.usage_flag_pointers["BONE_INDICES"] = &uses_bones;
+	actions.usage_flag_pointers["BONE_WEIGHTS"] = &uses_weights;
+
 	actions.uniforms = &uniforms;
 
 	Error err = MaterialStorage::get_singleton()->shaders.compiler_scene.compile(RS::SHADER_SPATIAL, code, &actions, path, gen_code);
@@ -3292,6 +3290,17 @@ void SceneShaderData::set_code(const String &p_code) {
 	cull_mode = Cull(cull_modei);
 	blend_mode = BlendMode(blend_modei);
 	alpha_antialiasing_mode = AlphaAntiAliasing(alpha_antialiasing_modei);
+	vertex_input_mask = uint32_t(uses_normal);
+	vertex_input_mask |= uses_tangent << 1;
+	vertex_input_mask |= uses_color << 2;
+	vertex_input_mask |= uses_uv << 3;
+	vertex_input_mask |= uses_uv2 << 4;
+	vertex_input_mask |= uses_custom0 << 5;
+	vertex_input_mask |= uses_custom1 << 6;
+	vertex_input_mask |= uses_custom2 << 7;
+	vertex_input_mask |= uses_custom3 << 8;
+	vertex_input_mask |= uses_bones << 9;
+	vertex_input_mask |= uses_weights << 10;
 
 #if 0
 	print_line("**compiling shader:");
@@ -3455,7 +3464,7 @@ GLES3::MaterialData *GLES3::_create_scene_material_func(ShaderData *p_shader) {
 
 void SceneMaterialData::bind_uniforms() {
 	// Bind Material Uniforms
-	glBindBufferBase(GL_UNIFORM_BUFFER, 3, uniform_buffer);
+	glBindBufferBase(GL_UNIFORM_BUFFER, SCENE_MATERIAL_UNIFORM_LOCATION, uniform_buffer);
 
 	RID *textures = texture_cache.ptrw();
 	ShaderCompiler::GeneratedCode::Texture *texture_uniforms = shader_data->texture_uniforms.ptrw();
diff --git a/drivers/gles3/storage/material_storage.h b/drivers/gles3/storage/material_storage.h
index f9901f0085..aa36dda4e6 100644
--- a/drivers/gles3/storage/material_storage.h
+++ b/drivers/gles3/storage/material_storage.h
@@ -279,14 +279,6 @@ struct SceneShaderData : public ShaderData {
 		CULL_BACK
 	};
 
-	enum CullVariant {
-		CULL_VARIANT_NORMAL,
-		CULL_VARIANT_REVERSED,
-		CULL_VARIANT_DOUBLE_SIDED,
-		CULL_VARIANT_MAX
-
-	};
-
 	enum AlphaAntiAliasing {
 		ALPHA_ANTIALIASING_OFF,
 		ALPHA_ANTIALIASING_ALPHA_TO_COVERAGE,
@@ -335,6 +327,18 @@ struct SceneShaderData : public ShaderData {
 	bool uses_time;
 	bool writes_modelview_or_projection;
 	bool uses_world_coordinates;
+	bool uses_tangent;
+	bool uses_color;
+	bool uses_uv;
+	bool uses_uv2;
+	bool uses_custom0;
+	bool uses_custom1;
+	bool uses_custom2;
+	bool uses_custom3;
+	bool uses_bones;
+	bool uses_weights;
+
+	uint32_t vertex_input_mask = 0;
 
 	uint64_t last_pass = 0;
 	uint32_t index = 0;
diff --git a/drivers/gles3/storage/mesh_storage.cpp b/drivers/gles3/storage/mesh_storage.cpp
index 41b5107b6c..a2b9cb6a62 100644
--- a/drivers/gles3/storage/mesh_storage.cpp
+++ b/drivers/gles3/storage/mesh_storage.cpp
@@ -194,6 +194,7 @@ void MeshStorage::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface)
 		glBindBuffer(GL_ARRAY_BUFFER, s->attribute_buffer);
 		glBufferData(GL_ARRAY_BUFFER, p_surface.attribute_data.size(), p_surface.attribute_data.ptr(), (s->format & RS::ARRAY_FLAG_USE_DYNAMIC_UPDATE) ? GL_DYNAMIC_DRAW : GL_STATIC_DRAW);
 		glBindBuffer(GL_ARRAY_BUFFER, 0); //unbind
+		s->attribute_buffer_size = p_surface.attribute_data.size();
 	}
 	if (p_surface.skin_data.size()) {
 		glGenBuffers(1, &s->skin_buffer);
@@ -216,6 +217,7 @@ void MeshStorage::mesh_add_surface(RID p_mesh, const RS::SurfaceData &p_surface)
 		glBufferData(GL_ELEMENT_ARRAY_BUFFER, p_surface.index_data.size(), p_surface.index_data.ptr(), GL_STATIC_DRAW);
 		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0); //unbind
 		s->index_count = p_surface.index_count;
+		s->index_buffer_size = p_surface.index_data.size();
 
 		if (p_surface.lods.size()) {
 			s->lods = memnew_arr(Mesh::Surface::LOD, p_surface.lods.size());
@@ -323,7 +325,97 @@ RID MeshStorage::mesh_surface_get_material(RID p_mesh, int p_surface) const {
 }
 
 RS::SurfaceData MeshStorage::mesh_get_surface(RID p_mesh, int p_surface) const {
-	return RS::SurfaceData();
+	Mesh *mesh = mesh_owner.get_or_null(p_mesh);
+	ERR_FAIL_COND_V(!mesh, RS::SurfaceData());
+	ERR_FAIL_UNSIGNED_INDEX_V((uint32_t)p_surface, mesh->surface_count, RS::SurfaceData());
+
+	Mesh::Surface &s = *mesh->surfaces[p_surface];
+
+	RS::SurfaceData sd;
+	sd.format = s.format;
+	{
+		Vector<uint8_t> ret;
+		ret.resize(s.vertex_buffer_size);
+		glBindBuffer(GL_ARRAY_BUFFER, s.vertex_buffer);
+
+#if defined(__EMSCRIPTEN__)
+		{
+			uint8_t *w = ret.ptrw();
+			glGetBufferSubData(GL_ARRAY_BUFFER, 0, s.vertex_buffer_size, w);
+		}
+#else
+		void *data = glMapBufferRange(GL_ARRAY_BUFFER, 0, s.vertex_buffer_size, GL_MAP_READ_BIT);
+		ERR_FAIL_NULL_V(data, RS::SurfaceData());
+		{
+			uint8_t *w = ret.ptrw();
+			memcpy(w, data, s.vertex_buffer_size);
+		}
+		glUnmapBuffer(GL_ARRAY_BUFFER);
+#endif
+		sd.vertex_data = ret;
+	}
+
+	if (s.attribute_buffer != 0) {
+		Vector<uint8_t> ret;
+		ret.resize(s.attribute_buffer_size);
+		glBindBuffer(GL_ARRAY_BUFFER, s.attribute_buffer);
+
+#if defined(__EMSCRIPTEN__)
+		{
+			uint8_t *w = ret.ptrw();
+			glGetBufferSubData(GL_ARRAY_BUFFER, 0, s.attribute_buffer_size, w);
+		}
+#else
+		void *data = glMapBufferRange(GL_ARRAY_BUFFER, 0, s.attribute_buffer_size, GL_MAP_READ_BIT);
+		ERR_FAIL_NULL_V(data, RS::SurfaceData());
+		{
+			uint8_t *w = ret.ptrw();
+			memcpy(w, data, s.attribute_buffer_size);
+		}
+		glUnmapBuffer(GL_ARRAY_BUFFER);
+#endif
+		sd.attribute_data = ret;
+	}
+
+	sd.vertex_count = s.vertex_count;
+	sd.index_count = s.index_count;
+	sd.primitive = s.primitive;
+
+	if (sd.index_count) {
+		Vector<uint8_t> ret;
+		ret.resize(s.index_buffer_size);
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, s.index_buffer);
+
+#if defined(__EMSCRIPTEN__)
+		{
+			uint8_t *w = ret.ptrw();
+			glGetBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, s.index_buffer_size, w);
+		}
+#else
+		void *data = glMapBufferRange(GL_ELEMENT_ARRAY_BUFFER, 0, s.index_buffer_size, GL_MAP_READ_BIT);
+		ERR_FAIL_NULL_V(data, RS::SurfaceData());
+		{
+			uint8_t *w = ret.ptrw();
+			memcpy(w, data, s.index_buffer_size);
+		}
+		glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER);
+#endif
+		sd.index_data = ret;
+		glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
+	}
+
+	sd.aabb = s.aabb;
+	for (uint32_t i = 0; i < s.lod_count; i++) {
+		RS::SurfaceData::LOD lod;
+		lod.edge_length = s.lods[i].edge_length;
+		//lod.index_data = RD::get_singleton()->buffer_get_data(s.lods[i].index_buffer);
+		sd.lods.push_back(lod);
+	}
+
+	sd.bone_aabbs = s.bone_aabbs;
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	return sd;
 }
 
 int MeshStorage::mesh_get_surface_count(RID p_mesh) const {
@@ -496,7 +588,6 @@ void MeshStorage::mesh_clear(RID p_mesh) {
 
 		if (s.index_buffer != 0) {
 			glDeleteBuffers(1, &s.index_buffer);
-			glDeleteVertexArrays(1, &s.index_array);
 		}
 		memdelete(mesh->surfaces[i]);
 	}
@@ -553,14 +644,14 @@ void MeshStorage::_mesh_surface_generate_version_for_input_mask(Mesh::Surface::V
 			case RS::ARRAY_NORMAL: {
 				attribs[i].offset = vertex_stride;
 				// Will need to change to accommodate octahedral compression
-				attribs[i].size = 1;
+				attribs[i].size = 4;
 				attribs[i].type = GL_UNSIGNED_INT_2_10_10_10_REV;
 				vertex_stride += sizeof(float);
 				attribs[i].normalized = GL_TRUE;
 			} break;
 			case RS::ARRAY_TANGENT: {
 				attribs[i].offset = vertex_stride;
-				attribs[i].size = 1;
+				attribs[i].size = 4;
 				attribs[i].type = GL_UNSIGNED_INT_2_10_10_10_REV;
 				vertex_stride += sizeof(float);
 				attribs[i].normalized = GL_TRUE;
@@ -629,14 +720,17 @@ void MeshStorage::_mesh_surface_generate_version_for_input_mask(Mesh::Surface::V
 			continue;
 		}
 		if (i <= RS::ARRAY_TANGENT) {
+			attribs[i].stride = vertex_stride;
 			if (mis) {
 				glBindBuffer(GL_ARRAY_BUFFER, mis->vertex_buffer);
 			} else {
 				glBindBuffer(GL_ARRAY_BUFFER, s->vertex_buffer);
 			}
 		} else if (i <= RS::ARRAY_CUSTOM3) {
+			attribs[i].stride = attributes_stride;
 			glBindBuffer(GL_ARRAY_BUFFER, s->attribute_buffer);
 		} else {
+			attribs[i].stride = skin_stride;
 			glBindBuffer(GL_ARRAY_BUFFER, s->skin_buffer);
 		}
 
@@ -645,7 +739,7 @@ void MeshStorage::_mesh_surface_generate_version_for_input_mask(Mesh::Surface::V
 		} else {
 			glVertexAttribPointer(i, attribs[i].size, attribs[i].type, attribs[i].normalized, attribs[i].stride, CAST_INT_TO_UCHAR_PTR(attribs[i].offset));
 		}
-		glEnableVertexAttribArray(attribs[i].index);
+		glEnableVertexAttribArray(i);
 	}
 
 	// Do not bind index here as we want to switch between index buffers for LOD
diff --git a/drivers/gles3/storage/mesh_storage.h b/drivers/gles3/storage/mesh_storage.h
index 6b0d0c83b2..dfb9046e7b 100644
--- a/drivers/gles3/storage/mesh_storage.h
+++ b/drivers/gles3/storage/mesh_storage.h
@@ -54,7 +54,6 @@ struct Mesh {
 		struct Attrib {
 			bool enabled;
 			bool integer;
-			GLuint index;
 			GLint size;
 			GLenum type;
 			GLboolean normalized;
@@ -69,6 +68,7 @@ struct Mesh {
 		GLuint skin_buffer = 0;
 		uint32_t vertex_count = 0;
 		uint32_t vertex_buffer_size = 0;
+		uint32_t attribute_buffer_size = 0;
 		uint32_t skin_buffer_size = 0;
 
 		// Cache vertex arrays so they can be created
@@ -84,8 +84,8 @@ struct Mesh {
 		uint32_t version_count = 0;
 
 		GLuint index_buffer = 0;
-		GLuint index_array = 0;
 		uint32_t index_count = 0;
+		uint32_t index_buffer_size = 0;
 
 		struct LOD {
 			float edge_length = 0.0;
@@ -357,6 +357,12 @@ public:
 		}
 	}
 
+	_FORCE_INLINE_ GLenum mesh_surface_get_index_type(void *p_surface) const {
+		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
+
+		return s->vertex_count <= 65536 ? GL_UNSIGNED_SHORT : GL_UNSIGNED_INT;
+	}
+
 	// Use this to cache Vertex Array Objects so they are only generated once
 	_FORCE_INLINE_ void mesh_surface_get_vertex_arrays_and_format(void *p_surface, uint32_t p_input_mask, GLuint &r_vertex_array_gl) {
 		Mesh::Surface *s = reinterpret_cast<Mesh::Surface *>(p_surface);
diff --git a/drivers/gles3/storage/texture_storage.cpp b/drivers/gles3/storage/texture_storage.cpp
index 6f2dc391d8..4396ca4f93 100644
--- a/drivers/gles3/storage/texture_storage.cpp
+++ b/drivers/gles3/storage/texture_storage.cpp
@@ -62,8 +62,9 @@ TextureStorage::TextureStorage() {
 
 			Ref<Image> image;
 			image.instantiate();
-			image->create(4, 4, false, Image::FORMAT_RGBA8);
+			image->create(4, 4, true, Image::FORMAT_RGBA8);
 			image->fill(Color(1, 1, 1, 1));
+			image->generate_mipmaps();
 
 			default_gl_textures[DEFAULT_GL_TEXTURE_WHITE] = texture_allocate();
 			texture_2d_initialize(default_gl_textures[DEFAULT_GL_TEXTURE_WHITE], image);
@@ -92,8 +93,9 @@ TextureStorage::TextureStorage() {
 		{ // black
 			Ref<Image> image;
 			image.instantiate();
-			image->create(4, 4, false, Image::FORMAT_RGBA8);
+			image->create(4, 4, true, Image::FORMAT_RGBA8);
 			image->fill(Color(0, 0, 0, 1));
+			image->generate_mipmaps();
 
 			default_gl_textures[DEFAULT_GL_TEXTURE_BLACK] = texture_allocate();
 			texture_2d_initialize(default_gl_textures[DEFAULT_GL_TEXTURE_BLACK], image);
@@ -117,8 +119,9 @@ TextureStorage::TextureStorage() {
 		{
 			Ref<Image> image;
 			image.instantiate();
-			image->create(4, 4, false, Image::FORMAT_RGBA8);
+			image->create(4, 4, true, Image::FORMAT_RGBA8);
 			image->fill(Color(0.5, 0.5, 1, 1));
+			image->generate_mipmaps();
 
 			default_gl_textures[DEFAULT_GL_TEXTURE_NORMAL] = texture_allocate();
 			texture_2d_initialize(default_gl_textures[DEFAULT_GL_TEXTURE_NORMAL], image);
@@ -127,8 +130,9 @@ TextureStorage::TextureStorage() {
 		{
 			Ref<Image> image;
 			image.instantiate();
-			image->create(4, 4, false, Image::FORMAT_RGBA8);
+			image->create(4, 4, true, Image::FORMAT_RGBA8);
 			image->fill(Color(1.0, 0.5, 1, 1));
+			image->generate_mipmaps();
 
 			default_gl_textures[DEFAULT_GL_TEXTURE_ANISO] = texture_allocate();
 			texture_2d_initialize(default_gl_textures[DEFAULT_GL_TEXTURE_ANISO], image);
@@ -189,18 +193,7 @@ TextureStorage::~TextureStorage() {
 	}
 }
 
-void TextureStorage::set_main_thread_id(Thread::ID p_id) {
-	_main_thread_id = p_id;
-}
-
-bool TextureStorage::_is_main_thread() {
-	//#if defined DEBUG_ENABLED && defined TOOLS_ENABLED
-	// must be called from main thread in OpenGL
-	bool is_main_thread = _main_thread_id == Thread::get_caller_id();
-	//#endif
-	return is_main_thread;
-}
-
+//TODO, move back to storage
 bool TextureStorage::can_create_resources_async() const {
 	return false;
 }
@@ -644,10 +637,14 @@ void TextureStorage::texture_2d_initialize(RID p_texture, const Ref<Image> &p_im
 	Texture texture;
 	texture.width = p_image->get_width();
 	texture.height = p_image->get_height();
+	texture.alloc_width = texture.width;
+	texture.alloc_height = texture.height;
+	texture.mipmaps = p_image->get_mipmap_count();
 	texture.format = p_image->get_format();
 	texture.type = Texture::TYPE_2D;
 	texture.target = GL_TEXTURE_2D;
-	texture.image_cache_2d = p_image; //TODO, remove this once texture_2d_get is implemented
+	_get_gl_image_and_format(Ref<Image>(), texture.format, 0, texture.real_format, texture.gl_format_cache, texture.gl_internal_format_cache, texture.gl_type_cache, texture.compressed, false);
+	//texture.total_data_size = p_image->get_image_data_size(); // verify that this returns size in bytes
 	texture.active = true;
 	glGenTextures(1, &texture.tex_id);
 	texture_owner.initialize_rid(p_texture, texture);
@@ -740,49 +737,66 @@ void TextureStorage::texture_3d_placeholder_initialize(RID p_texture) {
 }
 
 Ref<Image> TextureStorage::texture_2d_get(RID p_texture) const {
-	Texture *tex = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND_V(!tex, Ref<Image>());
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND_V(!texture, Ref<Image>());
 
 #ifdef TOOLS_ENABLED
-	if (tex->image_cache_2d.is_valid() && !tex->is_render_target) {
-		return tex->image_cache_2d;
+	if (texture->image_cache_2d.is_valid() && !texture->is_render_target) {
+		return texture->image_cache_2d;
 	}
 #endif
 
-	/*
-#ifdef TOOLS_ENABLED
-	if (tex->image_cache_2d.is_valid()) {
-		return tex->image_cache_2d;
+#ifdef GLES_OVER_GL
+	// OpenGL 3.3 supports glGetTexImage which is faster and simpler than glReadPixels.
+	Vector<uint8_t> data;
+
+	int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, texture->real_format, texture->mipmaps > 1);
+
+	data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
+	uint8_t *w = data.ptrw();
+
+	glActiveTexture(GL_TEXTURE0);
+
+	glBindTexture(texture->target, texture->tex_id);
+
+	glBindBuffer(GL_PIXEL_PACK_BUFFER, 0);
+
+	for (int i = 0; i < texture->mipmaps; i++) {
+		int ofs = Image::get_image_mipmap_offset(texture->alloc_width, texture->alloc_height, texture->real_format, i);
+
+		if (texture->compressed) {
+			glPixelStorei(GL_PACK_ALIGNMENT, 4);
+			glGetCompressedTexImage(texture->target, i, &w[ofs]);
+
+		} else {
+			glPixelStorei(GL_PACK_ALIGNMENT, 1);
+
+			glGetTexImage(texture->target, i, texture->gl_format_cache, texture->gl_type_cache, &w[ofs]);
+		}
 	}
-#endif
-	Vector<uint8_t> data = RD::get_singleton()->texture_get_data(tex->rd_texture, 0);
+
+	data.resize(data_size);
+
 	ERR_FAIL_COND_V(data.size() == 0, Ref<Image>());
 	Ref<Image> image;
-	image.instance();
-	image->create(tex->width, tex->height, tex->mipmaps > 1, tex->validated_format, data);
-	ERR_FAIL_COND_V(image->empty(), Ref<Image>());
-	if (tex->format != tex->validated_format) {
-		image->convert(tex->format);
+	image.instantiate();
+	image->create(texture->width, texture->height, texture->mipmaps > 1, texture->real_format, data);
+	ERR_FAIL_COND_V(image->is_empty(), Ref<Image>());
+	if (texture->format != texture->real_format) {
+		image->convert(texture->format);
 	}
+#else
+	// Support for Web and Mobile will come later.
+	Ref<Image> image;
+#endif
 
 #ifdef TOOLS_ENABLED
-	if (Engine::get_singleton()->is_editor_hint()) {
-		tex->image_cache_2d = image;
+	if (Engine::get_singleton()->is_editor_hint() && !texture->is_render_target) {
+		texture->image_cache_2d = image;
 	}
 #endif
-*/
-
-	/*
-	#ifdef TOOLS_ENABLED
-		if (Engine::get_singleton()->is_editor_hint() && !tex->is_render_target) {
-			tex->image_cache_2d = image;
-		}
-	#endif
-	*/
-
-	//	return image;
 
-	return Ref<Image>();
+	return image;
 }
 
 void TextureStorage::texture_replace(RID p_texture, RID p_by_texture) {
@@ -1357,6 +1371,9 @@ void TextureStorage::_update_render_target(RenderTarget *rt) {
 		}
 
 		texture->format = rt->image_format;
+		texture->real_format = rt->image_format;
+		texture->type = Texture::TYPE_2D;
+		texture->target = GL_TEXTURE_2D;
 		texture->gl_format_cache = rt->color_format;
 		texture->gl_type_cache = GL_UNSIGNED_BYTE;
 		texture->gl_internal_format_cache = rt->color_internal_format;
diff --git a/drivers/gles3/storage/texture_storage.h b/drivers/gles3/storage/texture_storage.h
index a841ff8f46..8281b8c596 100644
--- a/drivers/gles3/storage/texture_storage.h
+++ b/drivers/gles3/storage/texture_storage.h
@@ -141,6 +141,7 @@ struct Texture {
 	int alloc_width = 0;
 	int alloc_height = 0;
 	Image::Format format = Image::FORMAT_R8;
+	Image::Format real_format = Image::FORMAT_R8;
 
 	enum Type {
 		TYPE_2D,
@@ -370,9 +371,6 @@ private:
 
 	RID default_gl_textures[DEFAULT_GL_TEXTURE_MAX];
 
-	Thread::ID _main_thread_id = 0;
-	bool _is_main_thread();
-
 	/* Canvas Texture API */
 
 	RID_Owner<CanvasTexture, true> canvas_texture_owner;
@@ -440,8 +438,6 @@ public:
 	};
 	bool owns_texture(RID p_rid) { return texture_owner.owns(p_rid); };
 
-	void set_main_thread_id(Thread::ID p_id);
-
 	virtual bool can_create_resources_async() const override;
 
 	RID texture_create();