Merge pull request #59062 from BastiaanOlij/storagerd_texture

15 files changed, 2325 insertions, 1890 deletions

diff --git a/drivers/gles3/SCsub b/drivers/gles3/SCsub
index 987ddcd16e..fcb05a988d 100644
--- a/drivers/gles3/SCsub
+++ b/drivers/gles3/SCsub
@@ -5,3 +5,4 @@ Import("env")
 env.add_source_files(env.drivers_sources, "*.cpp")
 
 SConscript("shaders/SCsub")
+SConscript("storage/SCsub")
diff --git a/drivers/gles3/rasterizer_canvas_gles3.cpp b/drivers/gles3/rasterizer_canvas_gles3.cpp
index f25b7047d5..b47d2e08f1 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.cpp
+++ b/drivers/gles3/rasterizer_canvas_gles3.cpp
@@ -38,6 +38,8 @@
 
 #include "core/config/project_settings.h"
 #include "servers/rendering/rendering_server_default.h"
+#include "storage/canvas_texture_storage.h"
+#include "storage/config.h"
 
 #ifndef GLES_OVER_GL
 #define glClearDepth glClearDepthf
@@ -260,7 +262,7 @@ void RasterizerCanvasGLES3::_render_items(RID p_to_render_target, int p_item_cou
 				for (int ti = 0; ti < tc; i++) {
 					glActiveTexture(GL_TEXTURE0 + ti);
 
-					RasterizerStorageGLES3::Texture *t = storage->texture_owner.get_or_null(textures[ti].second);
+					GLES3::Texture *t = texture_storage->get_texture(textures[ti].second);
 
 					if (!t) {
 						switch (texture_uniforms[i].hint) {
@@ -915,20 +917,20 @@ void RasterizerCanvasGLES3::_bind_canvas_texture(RID p_texture, RS::CanvasItemTe
 	state.end_batch = true;
 	_render_batch(r_index);
 
-	RasterizerStorageGLES3::CanvasTexture *ct = nullptr;
+	GLES3::CanvasTexture *ct = nullptr;
 
-	RasterizerStorageGLES3::Texture *t = storage->texture_owner.get_or_null(p_texture);
+	GLES3::Texture *t = texture_storage->get_texture(p_texture);
 
 	if (t) {
 		//regular texture
 		if (!t->canvas_texture) {
-			t->canvas_texture = memnew(RasterizerStorageGLES3::CanvasTexture);
+			t->canvas_texture = memnew(GLES3::CanvasTexture);
 			t->canvas_texture->diffuse = p_texture;
 		}
 
 		ct = t->canvas_texture;
 	} else {
-		ct = storage->canvas_texture_owner.get_or_null(p_texture);
+		ct = GLES3::CanvasTextureStorage::get_singleton()->get_canvas_texture(p_texture);
 	}
 
 	if (!ct) {
@@ -943,7 +945,7 @@ void RasterizerCanvasGLES3::_bind_canvas_texture(RID p_texture, RS::CanvasItemTe
 	RS::CanvasItemTextureRepeat repeat = ct->texture_repeat != RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT ? ct->texture_repeat : p_base_repeat;
 	ERR_FAIL_COND(repeat == RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT);
 
-	RasterizerStorageGLES3::Texture *texture = storage->texture_owner.get_or_null(ct->diffuse);
+	GLES3::Texture *texture = texture_storage->get_texture(ct->diffuse);
 
 	if (!texture) {
 		state.current_tex = RID();
@@ -967,18 +969,18 @@ void RasterizerCanvasGLES3::_bind_canvas_texture(RID p_texture, RS::CanvasItemTe
 		texture->GLSetRepeat(GL_TEXTURE_2D, repeat);
 	}
 
-	RasterizerStorageGLES3::Texture *normal_map = storage->texture_owner.get_or_null(ct->normal_map);
+	GLES3::Texture *normal_map = texture_storage->get_texture(ct->normal_map);
 
 	if (!normal_map) {
 		state.current_normal = RID();
 		ct->use_normal_cache = false;
-		glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 6);
+		glActiveTexture(GL_TEXTURE0 + GLES3::Config::get_singleton()->max_texture_image_units - 6);
 		glBindTexture(GL_TEXTURE_2D, storage->resources.normal_tex);
 
 	} else {
 		normal_map = normal_map->get_ptr();
 
-		glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 6);
+		glActiveTexture(GL_TEXTURE0 + storage->config->max_texture_image_units - 6);
 		glBindTexture(GL_TEXTURE_2D, normal_map->tex_id);
 		state.current_normal = ct->normal_map;
 		ct->use_normal_cache = true;
@@ -986,18 +988,18 @@ void RasterizerCanvasGLES3::_bind_canvas_texture(RID p_texture, RS::CanvasItemTe
 		texture->GLSetRepeat(GL_TEXTURE_2D, repeat);
 	}
 
-	RasterizerStorageGLES3::Texture *specular_map = storage->texture_owner.get_or_null(ct->specular);
+	GLES3::Texture *specular_map = texture_storage->get_texture(ct->specular);
 
 	if (!specular_map) {
 		state.current_specular = RID();
 		ct->use_specular_cache = false;
-		glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 7);
+		glActiveTexture(GL_TEXTURE0 + storage->config->max_texture_image_units - 7);
 		glBindTexture(GL_TEXTURE_2D, storage->resources.white_tex);
 
 	} else {
 		specular_map = specular_map->get_ptr();
 
-		glActiveTexture(GL_TEXTURE0 + storage->config.max_texture_image_units - 7);
+		glActiveTexture(GL_TEXTURE0 + storage->config->max_texture_image_units - 7);
 		glBindTexture(GL_TEXTURE_2D, specular_map->tex_id);
 		state.current_specular = ct->specular;
 		ct->use_specular_cache = true;
@@ -1249,6 +1251,10 @@ void RasterizerCanvasGLES3::_allocate_instance_data_buffer() {
 }
 
 void RasterizerCanvasGLES3::initialize() {
+	// !BAS! shouldn't we be obtaining storage here as well?
+	canvas_texture_storage = GLES3::CanvasTextureStorage::get_singleton();
+	texture_storage = GLES3::TextureStorage::get_singleton();
+
 	// quad buffer
 	{
 		glGenBuffers(1, &data.canvas_quad_vertices);
@@ -1408,7 +1414,7 @@ void RasterizerCanvasGLES3::initialize() {
 	state.canvas_shader_default_version = state.canvas_shader.version_create();
 	state.canvas_shader.version_bind_shader(state.canvas_shader_default_version, CanvasShaderGLES3::MODE_QUAD);
 
-	//state.canvas_shader.set_conditional(CanvasOldShaderGLES3::USE_RGBA_SHADOWS, storage->config.use_rgba_2d_shadows);
+	//state.canvas_shader.set_conditional(CanvasOldShaderGLES3::USE_RGBA_SHADOWS, storage->config->use_rgba_2d_shadows);
 
 	//state.canvas_shader.bind();
 
@@ -1441,8 +1447,8 @@ void fragment() {
 		storage->material_set_shader(default_canvas_group_material, default_canvas_group_shader);
 	}
 
-	default_canvas_texture = storage->canvas_texture_allocate();
-	storage->canvas_texture_initialize(default_canvas_texture);
+	default_canvas_texture = canvas_texture_storage->canvas_texture_allocate();
+	canvas_texture_storage->canvas_texture_initialize(default_canvas_texture);
 
 	state.using_light = nullptr;
 	state.using_transparent_rt = false;
@@ -1456,7 +1462,7 @@ RasterizerCanvasGLES3::~RasterizerCanvasGLES3() {
 	state.canvas_shader.version_free(state.canvas_shader_default_version);
 	storage->free(default_canvas_group_material);
 	storage->free(default_canvas_group_shader);
-	storage->free(default_canvas_texture);
+	canvas_texture_storage->canvas_texture_free(default_canvas_texture);
 }
 
 void RasterizerCanvasGLES3::finalize() {
diff --git a/drivers/gles3/rasterizer_canvas_gles3.h b/drivers/gles3/rasterizer_canvas_gles3.h
index 908d79f9f8..1f57c2b5ea 100644
--- a/drivers/gles3/rasterizer_canvas_gles3.h
+++ b/drivers/gles3/rasterizer_canvas_gles3.h
@@ -37,6 +37,8 @@
 #include "rasterizer_storage_gles3.h"
 #include "servers/rendering/renderer_canvas_render.h"
 #include "servers/rendering/renderer_compositor.h"
+#include "storage/canvas_texture_storage.h"
+#include "storage/texture_storage.h"
 
 #include "shaders/canvas.glsl.gen.h"
 
@@ -184,7 +186,7 @@ public:
 		RID current_tex = RID();
 		RID current_normal = RID();
 		RID current_specular = RID();
-		RasterizerStorageGLES3::Texture *current_tex_ptr;
+		GLES3::Texture *current_tex_ptr;
 		RID current_shader_version = RID();
 		RS::PrimitiveType current_primitive = RS::PRIMITIVE_MAX;
 		uint32_t current_primitive_points = 0;
@@ -217,6 +219,8 @@ public:
 
 	RasterizerSceneGLES3 *scene_render;
 
+	GLES3::CanvasTextureStorage *canvas_texture_storage;
+	GLES3::TextureStorage *texture_storage;
 	RasterizerStorageGLES3 *storage;
 
 	void _set_uniforms();
diff --git a/drivers/gles3/rasterizer_gles3.cpp b/drivers/gles3/rasterizer_gles3.cpp
index 087bf36473..faadb2a4ed 100644
--- a/drivers/gles3/rasterizer_gles3.cpp
+++ b/drivers/gles3/rasterizer_gles3.cpp
@@ -195,7 +195,7 @@ typedef void (*DebugMessageCallbackARB)(DEBUGPROCARB callback, const void *userP
 void RasterizerGLES3::initialize() {
 	print_verbose("Using OpenGL video driver");
 
-	storage._main_thread_id = Thread::get_caller_id();
+	texture_storage.set_main_thread_id(Thread::get_caller_id());
 
 #ifdef GLAD_ENABLED
 	if (!gladLoadGL()) {
@@ -271,7 +271,7 @@ void RasterizerGLES3::prepare_for_blitting_render_targets() {
 void RasterizerGLES3::_blit_render_target_to_screen(RID p_render_target, DisplayServer::WindowID p_screen, const Rect2 &p_screen_rect) {
 	ERR_FAIL_COND(storage.frame.current_rt);
 
-	RasterizerStorageGLES3::RenderTarget *rt = storage.render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = storage.render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	// TODO: do we need a keep 3d linear option?
@@ -324,10 +324,10 @@ void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_c
 
 	canvas.canvas_begin();
 
-	RID texture = storage.texture_create();
-	//storage.texture_allocate(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), VS::TEXTURE_TYPE_2D, p_use_filter ? VS::TEXTURE_FLAG_FILTER : 0);
-	storage._texture_allocate_internal(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D);
-	storage.texture_set_data(texture, p_image);
+	RID texture = texture_storage.texture_create();
+	//texture_storage.texture_allocate(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), VS::TEXTURE_TYPE_2D, p_use_filter ? VS::TEXTURE_FLAG_FILTER : 0);
+	texture_storage._texture_allocate_internal(texture, p_image->get_width(), p_image->get_height(), 0, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D);
+	texture_storage.texture_set_data(texture, p_image);
 
 	Rect2 imgrect(0, 0, p_image->get_width(), p_image->get_height());
 	Rect2 screenrect;
@@ -349,13 +349,13 @@ void RasterizerGLES3::set_boot_image(const Ref<Image> &p_image, const Color &p_c
 		screenrect.position += ((Size2(win_size.width, win_size.height) - screenrect.size) / 2.0).floor();
 	}
 
-	RasterizerStorageGLES3::Texture *t = storage.texture_owner.get_or_null(texture);
-	glActiveTexture(GL_TEXTURE0 + storage.config.max_texture_image_units - 1);
+	GLES3::Texture *t = texture_storage.get_texture(texture);
+	glActiveTexture(GL_TEXTURE0 + config.max_texture_image_units - 1);
 	glBindTexture(GL_TEXTURE_2D, t->tex_id);
 	glBindTexture(GL_TEXTURE_2D, 0);
 	canvas.canvas_end();
 
-	storage.free(texture);
+	texture_storage.texture_free(texture);
 
 	end_frame(true);
 }
diff --git a/drivers/gles3/rasterizer_gles3.h b/drivers/gles3/rasterizer_gles3.h
index a641e189c5..93c58a8d9d 100644
--- a/drivers/gles3/rasterizer_gles3.h
+++ b/drivers/gles3/rasterizer_gles3.h
@@ -37,6 +37,10 @@
 #include "rasterizer_scene_gles3.h"
 #include "rasterizer_storage_gles3.h"
 #include "servers/rendering/renderer_compositor.h"
+#include "storage/canvas_texture_storage.h"
+#include "storage/config.h"
+#include "storage/render_target_storage.h"
+#include "storage/texture_storage.h"
 
 class RasterizerGLES3 : public RendererCompositor {
 private:
@@ -46,6 +50,9 @@ private:
 	double time_total = 0.0;
 
 protected:
+	GLES3::Config config;
+	GLES3::CanvasTextureStorage canvas_texture_storage;
+	GLES3::TextureStorage texture_storage;
 	RasterizerStorageGLES3 storage;
 	RasterizerCanvasGLES3 canvas;
 	RasterizerSceneGLES3 scene;
@@ -53,6 +60,8 @@ protected:
 	void _blit_render_target_to_screen(RID p_render_target, DisplayServer::WindowID p_screen, const Rect2 &p_screen_rect);
 
 public:
+	RendererCanvasTextureStorage *get_canvas_texture_storage() { return &canvas_texture_storage; }
+	RendererTextureStorage *get_texture_storage() { return &texture_storage; }
 	RendererStorage *get_storage() { return &storage; }
 	RendererCanvasRender *get_canvas() { return &canvas; }
 	RendererSceneRender *get_scene() { return &scene; }
diff --git a/drivers/gles3/rasterizer_storage_gles3.cpp b/drivers/gles3/rasterizer_storage_gles3.cpp
index dce515a96d..11d4af126c 100644
--- a/drivers/gles3/rasterizer_storage_gles3.cpp
+++ b/drivers/gles3/rasterizer_storage_gles3.cpp
@@ -40,45 +40,6 @@
 
 GLuint RasterizerStorageGLES3::system_fbo = 0;
 
-/* TEXTURE API */
-
-#define _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
-#define _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
-#define _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
-
-#define _EXT_COMPRESSED_RED_RGTC1_EXT 0x8DBB
-#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
-#define _EXT_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
-#define _EXT_COMPRESSED_RG_RGTC2 0x8DBD
-#define _EXT_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
-#define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
-#define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
-#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
-#define _EXT_ETC1_RGB8_OES 0x8D64
-
-#define _EXT_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
-#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
-#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
-#define _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
-
-#define _GL_TEXTURE_EXTERNAL_OES 0x8D65
-
-#ifdef GLES_OVER_GL
-#define _GL_HALF_FLOAT_OES 0x140B
-#else
-#define _GL_HALF_FLOAT_OES 0x8D61
-#endif
-
-#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
-
-#define _RED_OES 0x1903
-
-#define _DEPTH_COMPONENT24_OES 0x81A6
-
-#ifndef GLES_OVER_GL
-#define glClearDepth glClearDepthf
-#endif //!GLES_OVER_GL
-
 void RasterizerStorageGLES3::bind_quad_array() const {
 	//glBindBuffer(GL_ARRAY_BUFFER, resources.quadie);
 	//glVertexAttribPointer(RS::ARRAY_VERTEX, 2, GL_FLOAT, GL_FALSE, sizeof(float) * 4, 0);
@@ -88,1180 +49,6 @@ void RasterizerStorageGLES3::bind_quad_array() const {
 	//glEnableVertexAttribArray(RS::ARRAY_TEX_UV);
 }
 
-bool RasterizerStorageGLES3::can_create_resources_async() const {
-	return false;
-}
-
-Ref<Image> RasterizerStorageGLES3::_get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, Image::Format &r_real_format, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool p_force_decompress) const {
-	r_gl_format = 0;
-	Ref<Image> image = p_image;
-	r_compressed = false;
-	r_real_format = p_format;
-
-	bool need_decompress = false;
-
-	switch (p_format) {
-		case Image::FORMAT_L8: {
-#ifdef GLES_OVER_GL
-			r_gl_internal_format = GL_R8;
-			r_gl_format = GL_RED;
-			r_gl_type = GL_UNSIGNED_BYTE;
-#else
-			r_gl_internal_format = GL_LUMINANCE;
-			r_gl_format = GL_LUMINANCE;
-			r_gl_type = GL_UNSIGNED_BYTE;
-#endif
-		} break;
-		case Image::FORMAT_LA8: {
-#ifdef GLES_OVER_GL
-			r_gl_internal_format = GL_RG8;
-			r_gl_format = GL_RG;
-			r_gl_type = GL_UNSIGNED_BYTE;
-#else
-			r_gl_internal_format = GL_LUMINANCE_ALPHA;
-			r_gl_format = GL_LUMINANCE_ALPHA;
-			r_gl_type = GL_UNSIGNED_BYTE;
-#endif
-		} break;
-		case Image::FORMAT_R8: {
-			r_gl_internal_format = GL_R8;
-			r_gl_format = GL_RED;
-			r_gl_type = GL_UNSIGNED_BYTE;
-
-		} break;
-		case Image::FORMAT_RG8: {
-			r_gl_internal_format = GL_RG8;
-			r_gl_format = GL_RG;
-			r_gl_type = GL_UNSIGNED_BYTE;
-
-		} break;
-		case Image::FORMAT_RGB8: {
-			r_gl_internal_format = GL_RGB8;
-			r_gl_format = GL_RGB;
-			r_gl_type = GL_UNSIGNED_BYTE;
-			//r_srgb = true;
-
-		} break;
-		case Image::FORMAT_RGBA8: {
-			r_gl_format = GL_RGBA;
-			r_gl_internal_format = GL_RGBA8;
-			r_gl_type = GL_UNSIGNED_BYTE;
-			//r_srgb = true;
-
-		} break;
-		case Image::FORMAT_RGBA4444: {
-			r_gl_internal_format = GL_RGBA4;
-			r_gl_format = GL_RGBA;
-			r_gl_type = GL_UNSIGNED_SHORT_4_4_4_4;
-
-		} break;
-			//case Image::FORMAT_RGBA5551: {
-			//	r_gl_internal_format = GL_RGB5_A1;
-			//	r_gl_format = GL_RGBA;
-			//	r_gl_type = GL_UNSIGNED_SHORT_5_5_5_1;
-			//
-			//} break;
-		case Image::FORMAT_RF: {
-			r_gl_internal_format = GL_R32F;
-			r_gl_format = GL_RED;
-			r_gl_type = GL_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGF: {
-			r_gl_internal_format = GL_RG32F;
-			r_gl_format = GL_RG;
-			r_gl_type = GL_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGBF: {
-			r_gl_internal_format = GL_RGB32F;
-			r_gl_format = GL_RGB;
-			r_gl_type = GL_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGBAF: {
-			r_gl_internal_format = GL_RGBA32F;
-			r_gl_format = GL_RGBA;
-			r_gl_type = GL_FLOAT;
-
-		} break;
-		case Image::FORMAT_RH: {
-			r_gl_internal_format = GL_R16F;
-			r_gl_format = GL_RED;
-			r_gl_type = GL_HALF_FLOAT;
-		} break;
-		case Image::FORMAT_RGH: {
-			r_gl_internal_format = GL_RG16F;
-			r_gl_format = GL_RG;
-			r_gl_type = GL_HALF_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGBH: {
-			r_gl_internal_format = GL_RGB16F;
-			r_gl_format = GL_RGB;
-			r_gl_type = GL_HALF_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGBAH: {
-			r_gl_internal_format = GL_RGBA16F;
-			r_gl_format = GL_RGBA;
-			r_gl_type = GL_HALF_FLOAT;
-
-		} break;
-		case Image::FORMAT_RGBE9995: {
-			r_gl_internal_format = GL_RGB9_E5;
-			r_gl_format = GL_RGB;
-			r_gl_type = GL_UNSIGNED_INT_5_9_9_9_REV;
-
-		} break;
-		case Image::FORMAT_DXT1: {
-			if (config.s3tc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_DXT3: {
-			if (config.s3tc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_DXT5: {
-			if (config.s3tc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_RGTC_R: {
-			if (config.rgtc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RED_RGTC1_EXT;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_RGTC_RG: {
-			if (config.rgtc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_BPTC_RGBA: {
-			if (config.bptc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGBA_BPTC_UNORM;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_BPTC_RGBF: {
-			if (config.bptc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
-				r_gl_format = GL_RGB;
-				r_gl_type = GL_FLOAT;
-				r_compressed = true;
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_BPTC_RGBFU: {
-			if (config.bptc_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
-				r_gl_format = GL_RGB;
-				r_gl_type = GL_FLOAT;
-				r_compressed = true;
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC: {
-			if (config.etc_supported) {
-				r_gl_internal_format = _EXT_ETC1_RGB8_OES;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-
-		} break;
-		/*
-		case Image::FORMAT_ETC2_R11: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_R11_EAC;
-				r_gl_format = GL_RED;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_R11S: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_SIGNED_R11_EAC;
-				r_gl_format = GL_RED;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_RG11: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RG11_EAC;
-				r_gl_format = GL_RG;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_RG11S: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_SIGNED_RG11_EAC;
-				r_gl_format = GL_RG;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_RGB8: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGB8_ETC2;
-				r_gl_format = GL_RGB;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_RGBA8: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGBA8_ETC2_EAC;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		case Image::FORMAT_ETC2_RGB8A1: {
-			if (config.etc2_supported) {
-				r_gl_internal_format = _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
-				r_gl_format = GL_RGBA;
-				r_gl_type = GL_UNSIGNED_BYTE;
-				r_compressed = true;
-				//r_srgb = true;
-
-			} else {
-				need_decompress = true;
-			}
-		} break;
-		*/
-		default: {
-			ERR_FAIL_V(Ref<Image>());
-		}
-	}
-
-	if (need_decompress || p_force_decompress) {
-		if (!image.is_null()) {
-			image = image->duplicate();
-			image->decompress();
-			ERR_FAIL_COND_V(image->is_compressed(), image);
-			switch (image->get_format()) {
-				case Image::FORMAT_RGB8: {
-					r_gl_format = GL_RGB;
-					r_gl_internal_format = GL_RGB;
-					r_gl_type = GL_UNSIGNED_BYTE;
-					r_real_format = Image::FORMAT_RGB8;
-					r_compressed = false;
-				} break;
-				case Image::FORMAT_RGBA8: {
-					r_gl_format = GL_RGBA;
-					r_gl_internal_format = GL_RGBA;
-					r_gl_type = GL_UNSIGNED_BYTE;
-					r_real_format = Image::FORMAT_RGBA8;
-					r_compressed = false;
-				} break;
-				default: {
-					image->convert(Image::FORMAT_RGBA8);
-					r_gl_format = GL_RGBA;
-					r_gl_internal_format = GL_RGBA;
-					r_gl_type = GL_UNSIGNED_BYTE;
-					r_real_format = Image::FORMAT_RGBA8;
-					r_compressed = false;
-
-				} break;
-			}
-		}
-
-		return image;
-	}
-
-	return p_image;
-}
-
-static const GLenum _cube_side_enum[6] = {
-	GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
-	GL_TEXTURE_CUBE_MAP_POSITIVE_X,
-	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
-	GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
-	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
-	GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
-};
-
-RID RasterizerStorageGLES3::texture_allocate() {
-	RID id = texture_create();
-	ERR_FAIL_COND_V(id == RID(), id);
-	return id;
-}
-
-void RasterizerStorageGLES3::texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) {
-	Texture *tex = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!tex);
-
-	int w = p_image->get_width();
-	int h = p_image->get_height();
-
-	_texture_allocate_internal(p_texture, w, h, 1, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D, 0);
-	texture_set_data(p_texture, p_image);
-}
-
-void RasterizerStorageGLES3::texture_2d_layered_initialize(RID p_texture, const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
-}
-
-void RasterizerStorageGLES3::texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) {
-}
-
-void RasterizerStorageGLES3::texture_proxy_initialize(RID p_texture, RID p_base) {
-	texture_set_proxy(p_texture, p_base);
-}
-
-//RID RasterizerStorageGLES3::texture_2d_create(const Ref<Image> &p_image) {
-//	RID id = texture_create();
-//	ERR_FAIL_COND_V(id == RID(), id);
-
-//	int w = p_image->get_width();
-//	int h = p_image->get_height();
-
-//	texture_allocate(id, w, h, 1, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D, 0);
-
-//	texture_set_data(id, p_image);
-
-//	return id;
-//}
-
-//RID RasterizerStorageGLES3::texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
-//	return RID();
-//}
-
-//void RasterizerStorageGLES3::texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer) {
-//	// only 1 layer so far
-//	texture_set_data(p_texture, p_image);
-//}
-void RasterizerStorageGLES3::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {
-	// only 1 layer so far
-	texture_set_data(p_texture, p_image);
-}
-
-void RasterizerStorageGLES3::texture_2d_placeholder_initialize(RID p_texture) {
-}
-
-void RasterizerStorageGLES3::texture_2d_layered_placeholder_initialize(RID p_texture, RenderingServer::TextureLayeredType p_layered_type) {
-}
-
-void RasterizerStorageGLES3::texture_3d_placeholder_initialize(RID p_texture) {
-}
-
-Ref<Image> RasterizerStorageGLES3::texture_2d_get(RID p_texture) const {
-	Texture *tex = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND_V(!tex, Ref<Image>());
-
-	/*
-#ifdef TOOLS_ENABLED
-	if (tex->image_cache_2d.is_valid()) {
-		return tex->image_cache_2d;
-	}
-#endif
-	Vector<uint8_t> data = RD::get_singleton()->texture_get_data(tex->rd_texture, 0);
-	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);
-	}
-
-#ifdef TOOLS_ENABLED
-	if (Engine::get_singleton()->is_editor_hint()) {
-		tex->image_cache_2d = image;
-	}
-#endif
-*/
-	ERR_FAIL_COND_V(!tex->images.size(), Ref<Image>());
-
-	return tex->images[0];
-
-	//	return image;
-
-	//	return Ref<Image>();
-}
-
-void RasterizerStorageGLES3::texture_replace(RID p_texture, RID p_by_texture) {
-	Texture *tex_to = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!tex_to);
-	Texture *tex_from = texture_owner.get_or_null(p_by_texture);
-	ERR_FAIL_COND(!tex_from);
-
-	tex_to->destroy();
-	tex_to->copy_from(*tex_from);
-
-	// copy image data and upload to GL
-	tex_to->images.resize(tex_from->images.size());
-
-	for (int n = 0; n < tex_from->images.size(); n++) {
-		texture_set_data(p_texture, tex_from->images[n], n);
-	}
-
-	free(p_by_texture);
-}
-
-bool RasterizerStorageGLES3::_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;
-}
-
-RID RasterizerStorageGLES3::texture_create() {
-	ERR_FAIL_COND_V(!_is_main_thread(), RID());
-
-	Texture *texture = memnew(Texture);
-	ERR_FAIL_COND_V(!texture, RID());
-	glGenTextures(1, &texture->tex_id);
-	texture->active = false;
-	texture->total_data_size = 0;
-
-	return texture_owner.make_rid(texture);
-}
-
-void RasterizerStorageGLES3::_texture_allocate_internal(RID p_texture, int p_width, int p_height, int p_depth_3d, Image::Format p_format, RenderingDevice::TextureType p_type, uint32_t p_flags) {
-	//	GLenum format;
-	//	GLenum internal_format;
-	//	GLenum type;
-
-	//	bool compressed = false;
-
-	if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
-		p_flags &= ~TEXTURE_FLAG_MIPMAPS; // no mipies for video
-	}
-
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-	texture->width = p_width;
-	texture->height = p_height;
-	texture->format = p_format;
-	texture->flags = p_flags;
-	texture->stored_cube_sides = 0;
-	texture->type = p_type;
-
-	switch (p_type) {
-		case RenderingDevice::TEXTURE_TYPE_2D: {
-			texture->target = GL_TEXTURE_2D;
-			texture->images.resize(1);
-		} break;
-			//		case RenderingDevice::TEXTURE_TYPE_EXTERNAL: {
-			//#ifdef ANDROID_ENABLED
-			//			texture->target = _GL_TEXTURE_EXTERNAL_OES;
-			//#else
-			//			texture->target = GL_TEXTURE_2D;
-			//#endif
-			//			texture->images.resize(0);
-			//		} break;
-		case RenderingDevice::TEXTURE_TYPE_CUBE: {
-			texture->target = GL_TEXTURE_CUBE_MAP;
-			texture->images.resize(6);
-		} break;
-		case RenderingDevice::TEXTURE_TYPE_2D_ARRAY:
-		case RenderingDevice::TEXTURE_TYPE_3D: {
-			texture->target = GL_TEXTURE_3D;
-			ERR_PRINT("3D textures and Texture Arrays are not supported in OpenGL. Please switch to the Vulkan backend.");
-			return;
-		} break;
-		default: {
-			ERR_PRINT("Unknown texture type!");
-			return;
-		}
-	}
-
-#if 0
-	//		if (p_type != RS::TEXTURE_TYPE_EXTERNAL) {
-	if (p_type == RenderingDevice::TEXTURE_TYPE_2D) {
-		texture->alloc_width = texture->width;
-		texture->alloc_height = texture->height;
-		texture->resize_to_po2 = false;
-		if (!config.support_npot_repeat_mipmap) {
-			int po2_width = next_power_of_2(p_width);
-			int po2_height = next_power_of_2(p_height);
-
-			bool is_po2 = p_width == po2_width && p_height == po2_height;
-
-			if (!is_po2 && (p_flags & TEXTURE_FLAG_REPEAT || p_flags & TEXTURE_FLAG_MIPMAPS)) {
-				if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
-					//not supported
-					ERR_PRINT("Streaming texture for non power of 2 or has mipmaps on this hardware: " + texture->path + "'. Mipmaps and repeat disabled.");
-					texture->flags &= ~(TEXTURE_FLAG_REPEAT | TEXTURE_FLAG_MIPMAPS);
-				} else {
-					texture->alloc_height = po2_height;
-					texture->alloc_width = po2_width;
-					texture->resize_to_po2 = true;
-				}
-			}
-		}
-
-		GLenum format;
-		GLenum internal_format;
-		GLenum type;
-		bool compressed = false;
-
-		Image::Format real_format;
-		_get_gl_image_and_format(Ref<Image>(),
-				texture->format,
-				texture->flags,
-				real_format,
-				format,
-				internal_format,
-				type,
-				compressed,
-				texture->resize_to_po2);
-
-		texture->gl_format_cache = format;
-		texture->gl_type_cache = type;
-		texture->gl_internal_format_cache = internal_format;
-		texture->data_size = 0;
-		texture->mipmaps = 1;
-
-		texture->compressed = compressed;
-	}
-#endif
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(texture->target, texture->tex_id);
-
-	//	if (p_type == RS::TEXTURE_TYPE_EXTERNAL) {
-	//		glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	//		glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	//		glTexParameteri(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-	//		glTexParameteri(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	//	} else if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
-	//		//prealloc if video
-	//		glTexImage2D(texture->target, 0, internal_format, texture->alloc_width, texture->alloc_height, 0, format, type, NULL);
-	//	}
-
-	texture->active = true;
-}
-
-void RasterizerStorageGLES3::texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND(!_is_main_thread());
-
-	ERR_FAIL_COND(!texture);
-	if (texture->target == GL_TEXTURE_3D) {
-		// Target is set to a 3D texture or array texture, exit early to avoid spamming errors
-		return;
-	}
-	ERR_FAIL_COND(!texture->active);
-	ERR_FAIL_COND(texture->render_target);
-	ERR_FAIL_COND(p_image.is_null());
-	ERR_FAIL_COND(texture->format != p_image->get_format());
-
-	ERR_FAIL_COND(!p_image->get_width());
-	ERR_FAIL_COND(!p_image->get_height());
-
-	//	ERR_FAIL_COND(texture->type == RS::TEXTURE_TYPE_EXTERNAL);
-
-	GLenum type;
-	GLenum format;
-	GLenum internal_format;
-	bool compressed = false;
-
-	if (config.keep_original_textures && !(texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING)) {
-		texture->images.write[p_layer] = p_image;
-	}
-
-	// print_line("texture_set_data width " + itos (p_image->get_width()) + " height " + itos(p_image->get_height()));
-
-	Image::Format real_format;
-	Ref<Image> img = _get_gl_image_and_format(p_image, p_image->get_format(), texture->flags, real_format, format, internal_format, type, compressed, texture->resize_to_po2);
-
-	if (texture->resize_to_po2) {
-		if (p_image->is_compressed()) {
-			ERR_PRINT("Texture '" + texture->path + "' is required to be a power of 2 because it uses either mipmaps or repeat, so it was decompressed. This will hurt performance and memory usage.");
-		}
-
-		if (img == p_image) {
-			img = img->duplicate();
-		}
-		img->resize_to_po2(false);
-	}
-
-	if (config.shrink_textures_x2 && (p_image->has_mipmaps() || !p_image->is_compressed()) && !(texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING)) {
-		texture->alloc_height = MAX(1, texture->alloc_height / 2);
-		texture->alloc_width = MAX(1, texture->alloc_width / 2);
-
-		if (texture->alloc_width == img->get_width() / 2 && texture->alloc_height == img->get_height() / 2) {
-			img->shrink_x2();
-		} else if (img->get_format() <= Image::FORMAT_RGBA8) {
-			img->resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
-		}
-	}
-
-	GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP) ? _cube_side_enum[p_layer] : GL_TEXTURE_2D;
-
-	texture->data_size = img->get_data().size();
-	Vector<uint8_t> read = img->get_data();
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(texture->target, texture->tex_id);
-
-	texture->ignore_mipmaps = compressed && !img->has_mipmaps();
-
-	// set filtering and repeat state
-	_texture_set_state_from_flags(texture);
-
-	//set swizle for older format compatibility
-#ifdef GLES_OVER_GL
-	switch (texture->format) {
-		case Image::FORMAT_L8: {
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ONE);
-
-		} break;
-		case Image::FORMAT_LA8: {
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_GREEN);
-		} break;
-		default: {
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
-			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
-
-		} break;
-	}
-#endif
-
-	int mipmaps = ((texture->flags & TEXTURE_FLAG_MIPMAPS) && img->has_mipmaps()) ? img->get_mipmap_count() + 1 : 1;
-
-	int w = img->get_width();
-	int h = img->get_height();
-
-	int tsize = 0;
-
-	for (int i = 0; i < mipmaps; i++) {
-		int size, ofs;
-		img->get_mipmap_offset_and_size(i, ofs, size);
-
-		if (compressed) {
-			glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
-
-			int bw = w;
-			int bh = h;
-
-			glCompressedTexImage2D(blit_target, i, internal_format, bw, bh, 0, size, &read[ofs]);
-		} else {
-			glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
-			if (texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
-				glTexSubImage2D(blit_target, i, 0, 0, w, h, format, type, &read[ofs]);
-			} else {
-				glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type, &read[ofs]);
-			}
-		}
-
-		tsize += size;
-
-		w = MAX(1, w >> 1);
-		h = MAX(1, h >> 1);
-	}
-
-	info.texture_mem -= texture->total_data_size;
-	texture->total_data_size = tsize;
-	info.texture_mem += texture->total_data_size;
-
-	// printf("texture: %i x %i - size: %i - total: %i\n", texture->width, texture->height, tsize, info.texture_mem);
-
-	texture->stored_cube_sides |= (1 << p_layer);
-
-	if ((texture->flags & TEXTURE_FLAG_MIPMAPS) && mipmaps == 1 && !texture->ignore_mipmaps && (texture->type != RenderingDevice::TEXTURE_TYPE_CUBE || texture->stored_cube_sides == (1 << 6) - 1)) {
-		//generate mipmaps if they were requested and the image does not contain them
-		glGenerateMipmap(texture->target);
-	}
-
-	texture->mipmaps = mipmaps;
-}
-
-void RasterizerStorageGLES3::texture_set_data_partial(RID p_texture, const Ref<Image> &p_image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int p_dst_mip, int p_layer) {
-	// TODO
-	ERR_PRINT("Not implemented (ask Karroffel to do it :p)");
-}
-
-/*
-Ref<Image> RasterizerStorageGLES3::texture_get_data(RID p_texture, int p_layer) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, Ref<Image>());
-	ERR_FAIL_COND_V(!texture->active, Ref<Image>());
-	ERR_FAIL_COND_V(texture->data_size == 0 && !texture->render_target, Ref<Image>());
-
-	if (texture->type == RS::TEXTURE_TYPE_CUBEMAP && p_layer < 6 && p_layer >= 0 && !texture->images[p_layer].is_null()) {
-		return texture->images[p_layer];
-	}
-
-#ifdef GLES_OVER_GL
-
-	Image::Format real_format;
-	GLenum gl_format;
-	GLenum gl_internal_format;
-	GLenum gl_type;
-	bool compressed;
-	_get_gl_image_and_format(Ref<Image>(), texture->format, texture->flags, real_format, gl_format, gl_internal_format, gl_type, compressed, false);
-
-	PoolVector<uint8_t> data;
-
-	int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, real_format, texture->mipmaps > 1);
-
-	data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
-	PoolVector<uint8_t>::Write wb = data.write();
-
-	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, real_format, i);
-
-		if (texture->compressed) {
-			glPixelStorei(GL_PACK_ALIGNMENT, 4);
-			glGetCompressedTexImage(texture->target, i, &wb[ofs]);
-		} else {
-			glPixelStorei(GL_PACK_ALIGNMENT, 1);
-			glGetTexImage(texture->target, i, texture->gl_format_cache, texture->gl_type_cache, &wb[ofs]);
-		}
-	}
-
-	wb.release();
-
-	data.resize(data_size);
-
-	Image *img = memnew(Image(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1, real_format, data));
-
-	return Ref<Image>(img);
-#else
-
-	Image::Format real_format;
-	GLenum gl_format;
-	GLenum gl_internal_format;
-	GLenum gl_type;
-	bool compressed;
-	_get_gl_image_and_format(Ref<Image>(), texture->format, texture->flags, real_format, gl_format, gl_internal_format, gl_type, compressed, texture->resize_to_po2);
-
-	PoolVector<uint8_t> data;
-
-	int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, Image::FORMAT_RGBA8, false);
-
-	data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
-	PoolVector<uint8_t>::Write wb = data.write();
-
-	GLuint temp_framebuffer;
-	glGenFramebuffers(1, &temp_framebuffer);
-
-	GLuint temp_color_texture;
-	glGenTextures(1, &temp_color_texture);
-
-	glBindFramebuffer(GL_FRAMEBUFFER, temp_framebuffer);
-
-	glBindTexture(GL_TEXTURE_2D, temp_color_texture);
-	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture->alloc_width, texture->alloc_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
-
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
-	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
-	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, temp_color_texture, 0);
-
-	glDepthMask(GL_FALSE);
-	glDisable(GL_DEPTH_TEST);
-	glDisable(GL_CULL_FACE);
-	glDisable(GL_BLEND);
-	glDepthFunc(GL_LEQUAL);
-	glColorMask(1, 1, 1, 1);
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(GL_TEXTURE_2D, texture->tex_id);
-
-	glViewport(0, 0, texture->alloc_width, texture->alloc_height);
-
-	shaders.copy.bind();
-
-	glClearColor(0.0, 0.0, 0.0, 0.0);
-	glClear(GL_COLOR_BUFFER_BIT);
-	bind_quad_array();
-	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
-	glBindBuffer(GL_ARRAY_BUFFER, 0);
-
-	glReadPixels(0, 0, texture->alloc_width, texture->alloc_height, GL_RGBA, GL_UNSIGNED_BYTE, &wb[0]);
-
-	glDeleteTextures(1, &temp_color_texture);
-
-	glBindFramebuffer(GL_FRAMEBUFFER, 0);
-	glDeleteFramebuffers(1, &temp_framebuffer);
-
-	wb.release();
-
-	data.resize(data_size);
-
-	Image *img = memnew(Image(texture->alloc_width, texture->alloc_height, false, Image::FORMAT_RGBA8, data));
-	if (!texture->compressed) {
-		img->convert(real_format);
-	}
-
-	return Ref<Image>(img);
-
-#endif
-}
-*/
-
-void RasterizerStorageGLES3::_texture_set_state_from_flags(Texture *p_tex) {
-	if ((p_tex->flags & TEXTURE_FLAG_MIPMAPS) && !p_tex->ignore_mipmaps) {
-		if (p_tex->flags & TEXTURE_FLAG_FILTER) {
-			// these do not exactly correspond ...
-			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS);
-			//texture->glTexParam_MinFilter(texture->target, config.use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
-		} else {
-			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
-			//texture->glTexParam_MinFilter(texture->target, config.use_fast_texture_filter ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST_MIPMAP_LINEAR);
-		}
-	} else {
-		if (p_tex->flags & TEXTURE_FLAG_FILTER) {
-			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR);
-			//texture->glTexParam_MinFilter(texture->target, GL_LINEAR);
-		} else {
-			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST);
-			//			texture->glTexParam_MinFilter(texture->target, GL_NEAREST);
-		}
-	}
-
-	if (((p_tex->flags & TEXTURE_FLAG_REPEAT) || (p_tex->flags & TEXTURE_FLAG_MIRRORED_REPEAT)) && p_tex->target != GL_TEXTURE_CUBE_MAP) {
-		if (p_tex->flags & TEXTURE_FLAG_MIRRORED_REPEAT) {
-			p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_MIRROR);
-		} else {
-			p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
-		}
-	} else {
-		p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
-	}
-}
-
-void RasterizerStorageGLES3::texture_set_flags(RID p_texture, uint32_t p_flags) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	bool had_mipmaps = texture->flags & TEXTURE_FLAG_MIPMAPS;
-
-	texture->flags = p_flags;
-
-	glActiveTexture(GL_TEXTURE0);
-	glBindTexture(texture->target, texture->tex_id);
-
-	// set filtering and repeat state
-	_texture_set_state_from_flags(texture);
-
-	if ((texture->flags & TEXTURE_FLAG_MIPMAPS) && !texture->ignore_mipmaps) {
-		if (!had_mipmaps && texture->mipmaps == 1) {
-			glGenerateMipmap(texture->target);
-		}
-	}
-}
-
-uint32_t RasterizerStorageGLES3::texture_get_flags(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, 0);
-
-	return texture->flags;
-}
-
-Image::Format RasterizerStorageGLES3::texture_get_format(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, Image::FORMAT_L8);
-
-	return texture->format;
-}
-
-RenderingDevice::TextureType RasterizerStorageGLES3::texture_get_type(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, RenderingDevice::TEXTURE_TYPE_2D);
-
-	return texture->type;
-}
-
-uint32_t RasterizerStorageGLES3::texture_get_texid(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, 0);
-
-	return texture->tex_id;
-}
-
-void RasterizerStorageGLES3::texture_bind(RID p_texture, uint32_t p_texture_no) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND(!texture);
-
-	glActiveTexture(GL_TEXTURE0 + p_texture_no);
-	glBindTexture(texture->target, texture->tex_id);
-}
-
-uint32_t RasterizerStorageGLES3::texture_get_width(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, 0);
-
-	return texture->width;
-}
-
-uint32_t RasterizerStorageGLES3::texture_get_height(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, 0);
-
-	return texture->height;
-}
-
-uint32_t RasterizerStorageGLES3::texture_get_depth(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND_V(!texture, 0);
-
-	return texture->depth;
-}
-
-void RasterizerStorageGLES3::texture_set_size_override(RID p_texture, int p_width, int p_height) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-
-	ERR_FAIL_COND(!texture);
-	ERR_FAIL_COND(texture->render_target);
-
-	ERR_FAIL_COND(p_width <= 0 || p_width > 16384);
-	ERR_FAIL_COND(p_height <= 0 || p_height > 16384);
-	//real texture size is in alloc width and height
-	texture->width = p_width;
-	texture->height = p_height;
-}
-
-void RasterizerStorageGLES3::texture_set_path(RID p_texture, const String &p_path) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	texture->path = p_path;
-}
-
-String RasterizerStorageGLES3::texture_get_path(RID p_texture) const {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND_V(!texture, "");
-
-	return texture->path;
-}
-
-void RasterizerStorageGLES3::texture_debug_usage(List<RS::TextureInfo> *r_info) {
-	List<RID> textures;
-	texture_owner.get_owned_list(&textures);
-
-	for (List<RID>::Element *E = textures.front(); E; E = E->next()) {
-		Texture *t = texture_owner.get_or_null(E->get());
-		if (!t) {
-			continue;
-		}
-		RS::TextureInfo tinfo;
-		tinfo.path = t->path;
-		tinfo.format = t->format;
-		tinfo.width = t->alloc_width;
-		tinfo.height = t->alloc_height;
-		tinfo.depth = 0;
-		tinfo.bytes = t->total_data_size;
-		r_info->push_back(tinfo);
-	}
-}
-
-void RasterizerStorageGLES3::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
-	config.shrink_textures_x2 = p_enable;
-}
-
-void RasterizerStorageGLES3::textures_keep_original(bool p_enable) {
-	config.keep_original_textures = p_enable;
-}
-
-Size2 RasterizerStorageGLES3::texture_size_with_proxy(RID p_texture) {
-	const Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND_V(!texture, Size2());
-	if (texture->proxy) {
-		return Size2(texture->proxy->width, texture->proxy->height);
-	} else {
-		return Size2(texture->width, texture->height);
-	}
-}
-
-// example use in 3.2
-// VS::get_singleton()->texture_set_proxy(default_texture->proxy, texture_rid);
-
-// p_proxy is the source (pre-existing) texture?
-// and p_texture is the one that is being made into a proxy?
-//This naming is confusing. Comments!!!
-
-// The naming of the parameters seemed to be reversed?
-// The p_proxy is the source texture
-// and p_texture is actually the proxy????
-
-void RasterizerStorageGLES3::texture_set_proxy(RID p_texture, RID p_proxy) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	if (texture->proxy) {
-		texture->proxy->proxy_owners.erase(texture);
-		texture->proxy = nullptr;
-	}
-
-	if (p_proxy.is_valid()) {
-		Texture *proxy = texture_owner.get_or_null(p_proxy);
-		ERR_FAIL_COND(!proxy);
-		ERR_FAIL_COND(proxy == texture);
-		proxy->proxy_owners.insert(texture);
-		texture->proxy = proxy;
-	}
-}
-
-void RasterizerStorageGLES3::texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	texture->redraw_if_visible = p_enable;
-}
-
-void RasterizerStorageGLES3::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	texture->detect_3d = p_callback;
-	texture->detect_3d_ud = p_userdata;
-}
-
-void RasterizerStorageGLES3::texture_set_detect_srgb_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	texture->detect_srgb = p_callback;
-	texture->detect_srgb_ud = p_userdata;
-}
-
-void RasterizerStorageGLES3::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
-	Texture *texture = texture_owner.get_or_null(p_texture);
-	ERR_FAIL_COND(!texture);
-
-	texture->detect_normal = p_callback;
-	texture->detect_normal_ud = p_userdata;
-}
-
-RID RasterizerStorageGLES3::texture_create_radiance_cubemap(RID p_source, int p_resolution) const {
-	return RID();
-}
-
-RID RasterizerStorageGLES3::canvas_texture_allocate() {
-	return canvas_texture_owner.allocate_rid();
-}
-
-void RasterizerStorageGLES3::canvas_texture_initialize(RID p_rid) {
-	canvas_texture_owner.initialize_rid(p_rid);
-}
-
-void RasterizerStorageGLES3::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
-	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
-	switch (p_channel) {
-		case RS::CANVAS_TEXTURE_CHANNEL_DIFFUSE: {
-			ct->diffuse = p_texture;
-		} break;
-		case RS::CANVAS_TEXTURE_CHANNEL_NORMAL: {
-			ct->normal_map = p_texture;
-		} break;
-		case RS::CANVAS_TEXTURE_CHANNEL_SPECULAR: {
-			ct->specular = p_texture;
-		} break;
-	}
-}
-
-void RasterizerStorageGLES3::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) {
-	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
-	ct->specular_color.r = p_specular_color.r;
-	ct->specular_color.g = p_specular_color.g;
-	ct->specular_color.b = p_specular_color.b;
-	ct->specular_color.a = p_shininess;
-}
-
-void RasterizerStorageGLES3::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
-	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
-	ct->texture_filter = p_filter;
-}
-void RasterizerStorageGLES3::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
-	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
-	ct->texture_repeat = p_repeat;
-}
-
 RID RasterizerStorageGLES3::sky_create() {
 	Sky *sky = memnew(Sky);
 	sky->radiance = 0;
@@ -1666,7 +453,7 @@ void RasterizerStorageGLES3::shader_get_param_list(RID p_shader, List<PropertyIn
 void RasterizerStorageGLES3::shader_set_default_texture_param(RID p_shader, const StringName &p_name, RID p_texture, int p_index) {
 	Shader *shader = shader_owner.get_or_null(p_shader);
 	ERR_FAIL_COND(!shader);
-	ERR_FAIL_COND(p_texture.is_valid() && !texture_owner.owns(p_texture));
+	ERR_FAIL_COND(p_texture.is_valid() && !GLES3::TextureStorage::get_singleton()->owns_texture(p_texture));
 
 	if (!p_texture.is_valid()) {
 		if (shader->default_textures.has(p_name) && shader->default_textures[p_name].has(p_index)) {
@@ -2897,7 +1684,7 @@ bool RasterizerStorageGLES3::particles_is_inactive(RID p_particles) const {
 /* RENDER TARGET */
 
 void RasterizerStorageGLES3::_set_current_render_target(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 
 	if (rt) {
 		if (rt->allocate_is_dirty) {
@@ -2923,7 +1710,7 @@ void RasterizerStorageGLES3::_set_current_render_target(RID p_render_target) {
 	}
 }
 
-void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
+void RasterizerStorageGLES3::_render_target_allocate(GLES3::RenderTarget *rt) {
 	// do not allocate a render target with no size
 	if (rt->width <= 0 || rt->height <= 0) {
 		return;
@@ -2964,7 +1751,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 	{
 		/* Front FBO */
 
-		Texture *texture = texture_owner.get_or_null(rt->texture);
+		GLES3::Texture *texture = GLES3::TextureStorage::get_singleton()->get_texture(rt->texture);
 		ERR_FAIL_COND(!texture);
 
 		// framebuffer
@@ -2977,7 +1764,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 		glTexImage2D(GL_TEXTURE_2D, 0, color_internal_format, rt->width, rt->height, 0, color_format, color_type, nullptr);
 
-		if (texture->flags & TEXTURE_FLAG_FILTER) {
+		if (texture->flags & GLES3::TEXTURE_FLAG_FILTER) {
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
 		} else {
@@ -2992,10 +1779,10 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 		// depth
 
-		if (config.support_depth_texture) {
+		if (config->support_depth_texture) {
 			glGenTextures(1, &rt->depth);
 			glBindTexture(GL_TEXTURE_2D, rt->depth);
-			glTexImage2D(GL_TEXTURE_2D, 0, config.depth_internalformat, rt->width, rt->height, 0, GL_DEPTH_COMPONENT, config.depth_type, nullptr);
+			glTexImage2D(GL_TEXTURE_2D, 0, config->depth_internalformat, rt->width, rt->height, 0, GL_DEPTH_COMPONENT, config->depth_type, nullptr);
 
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -3007,7 +1794,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 			glGenRenderbuffers(1, &rt->depth);
 			glBindRenderbuffer(GL_RENDERBUFFER, rt->depth);
 
-			glRenderbufferStorage(GL_RENDERBUFFER, config.depth_buffer_internalformat, rt->width, rt->height);
+			glRenderbufferStorage(GL_RENDERBUFFER, config->depth_buffer_internalformat, rt->width, rt->height);
 
 			glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->depth);
 		}
@@ -3016,7 +1803,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 		if (status != GL_FRAMEBUFFER_COMPLETE) {
 			glDeleteFramebuffers(1, &rt->fbo);
-			if (config.support_depth_texture) {
+			if (config->support_depth_texture) {
 				glDeleteTextures(1, &rt->depth);
 			} else {
 				glDeleteRenderbuffers(1, &rt->depth);
@@ -3045,7 +1832,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 		texture->alloc_height = rt->height;
 		texture->active = true;
 
-		texture_set_flags(rt->texture, texture->flags);
+		GLES3::TextureStorage::get_singleton()->texture_set_flags(rt->texture, texture->flags);
 	}
 
 	/* BACK FBO */
@@ -3071,7 +1858,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 		glGenRenderbuffers(1, &rt->multisample_depth);
 		glBindRenderbuffer(GL_RENDERBUFFER, rt->multisample_depth);
-		glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, config.depth_buffer_internalformat, rt->width, rt->height);
+		glRenderbufferStorageMultisample(GL_RENDERBUFFER, msaa, config->depth_buffer_internalformat, rt->width, rt->height);
 
 		glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->multisample_depth);
 
@@ -3160,7 +1947,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 			int fb_h = h;
 
 			while (true) {
-				RenderTarget::MipMaps::Size mm;
+				GLES3::RenderTarget::MipMaps::Size mm;
 				mm.width = w;
 				mm.height = h;
 				rt->mip_maps[i].sizes.push_back(mm);
@@ -3178,7 +1965,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 			GLsizei width = fb_w;
 			GLsizei height = fb_h;
 
-			if (config.render_to_mipmap_supported) {
+			if (config->render_to_mipmap_supported) {
 				glGenTextures(1, &rt->mip_maps[i].color);
 				glBindTexture(GL_TEXTURE_2D, rt->mip_maps[i].color);
 
@@ -3211,12 +1998,12 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 			glDepthMask(GL_TRUE);
 
 			for (int j = 0; j < rt->mip_maps[i].sizes.size(); j++) {
-				RenderTarget::MipMaps::Size &mm = rt->mip_maps[i].sizes.write[j];
+				GLES3::RenderTarget::MipMaps::Size &mm = rt->mip_maps[i].sizes.write[j];
 
 				glGenFramebuffers(1, &mm.fbo);
 				bind_framebuffer(mm.fbo);
 
-				if (config.render_to_mipmap_supported) {
+				if (config->render_to_mipmap_supported) {
 					glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->mip_maps[i].color, j);
 				} else {
 					glBindTexture(GL_TEXTURE_2D, rt->mip_maps[i].sizes[j].color);
@@ -3225,7 +2012,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 				bool used_depth = false;
 				if (j == 0 && i == 0) { //use always
-					if (config.support_depth_texture) {
+					if (config->support_depth_texture) {
 						glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, rt->depth, 0);
 					} else {
 						glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->depth);
@@ -3250,7 +2037,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 
 			rt->mip_maps[i].levels = level;
 
-			if (config.render_to_mipmap_supported) {
+			if (config->render_to_mipmap_supported) {
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR_MIPMAP_LINEAR);
 				glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
@@ -3263,7 +2050,7 @@ void RasterizerStorageGLES3::_render_target_allocate(RenderTarget *rt) {
 	bind_framebuffer_system();
 }
 
-void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
+void RasterizerStorageGLES3::_render_target_clear(GLES3::RenderTarget *rt) {
 	// there is nothing to clear when DIRECT_TO_SCREEN is used
 	if (rt->flags[RENDER_TARGET_DIRECT_TO_SCREEN]) {
 		return;
@@ -3280,20 +2067,20 @@ void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
 		glDeleteFramebuffers(1, &rt->external.fbo);
 
 		// clean up our texture
-		Texture *t = texture_owner.get_or_null(rt->external.texture);
+		GLES3::Texture *t = GLES3::TextureStorage::get_singleton()->get_texture(rt->external.texture);
 		t->alloc_height = 0;
 		t->alloc_width = 0;
 		t->width = 0;
 		t->height = 0;
 		t->active = false;
-		texture_owner.free(rt->external.texture);
+		GLES3::TextureStorage::get_singleton()->texture_free(rt->external.texture);
 		memdelete(t);
 
 		rt->external.fbo = 0;
 	}
 
 	if (rt->depth) {
-		if (config.support_depth_texture) {
+		if (config->support_depth_texture) {
 			glDeleteTextures(1, &rt->depth);
 		} else {
 			glDeleteRenderbuffers(1, &rt->depth);
@@ -3302,7 +2089,7 @@ void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
 		rt->depth = 0;
 	}
 
-	Texture *tex = texture_owner.get_or_null(rt->texture);
+	GLES3::Texture *tex = GLES3::TextureStorage::get_singleton()->get_texture(rt->texture);
 	tex->alloc_height = 0;
 	tex->alloc_width = 0;
 	tex->width = 0;
@@ -3345,8 +2132,8 @@ void RasterizerStorageGLES3::_render_target_clear(RenderTarget *rt) {
 }
 
 RID RasterizerStorageGLES3::render_target_create() {
-	RenderTarget *rt = memnew(RenderTarget);
-	Texture *t = memnew(Texture);
+	GLES3::RenderTarget *rt = memnew(GLES3::RenderTarget);
+	GLES3::Texture *t = memnew(GLES3::Texture);
 
 	t->type = RenderingDevice::TEXTURE_TYPE_2D;
 	t->flags = 0;
@@ -3368,12 +2155,12 @@ RID RasterizerStorageGLES3::render_target_create() {
 	t->tex_id = 0;
 	t->render_target = rt;
 
-	rt->texture = texture_owner.make_rid(t);
+	rt->texture = GLES3::TextureStorage::get_singleton()->make_rid(t);
 	return render_target_owner.make_rid(rt);
 }
 
 void RasterizerStorageGLES3::render_target_set_position(RID p_render_target, int p_x, int p_y) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	rt->x = p_x;
@@ -3381,7 +2168,7 @@ void RasterizerStorageGLES3::render_target_set_position(RID p_render_target, int
 }
 
 void RasterizerStorageGLES3::render_target_set_size(RID p_render_target, int p_width, int p_height, uint32_t p_view_count) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	if (p_width == rt->width && p_height == rt->height) {
@@ -3401,14 +2188,14 @@ void RasterizerStorageGLES3::render_target_set_size(RID p_render_target, int p_w
 
 // TODO: convert to Size2i internally
 Size2i RasterizerStorageGLES3::render_target_get_size(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, Size2());
 
 	return Size2i(rt->width, rt->height);
 }
 
 RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
 	if (rt->external.fbo == 0) {
@@ -3419,7 +2206,7 @@ RID RasterizerStorageGLES3::render_target_get_texture(RID p_render_target) {
 }
 
 void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_target, unsigned int p_texture_id) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	if (p_texture_id == 0) {
@@ -3433,13 +2220,13 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 			}
 
 			// clean up our texture
-			Texture *t = texture_owner.get_or_null(rt->external.texture);
+			GLES3::Texture *t = GLES3::TextureStorage::get_singleton()->get_texture(rt->external.texture);
 			t->alloc_height = 0;
 			t->alloc_width = 0;
 			t->width = 0;
 			t->height = 0;
 			t->active = false;
-			texture_owner.free(rt->external.texture);
+			GLES3::TextureStorage::get_singleton()->texture_free(rt->external.texture);
 			memdelete(t);
 
 			rt->external.fbo = 0;
@@ -3447,7 +2234,7 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 			rt->external.depth = 0;
 		}
 	} else {
-		Texture *t;
+		GLES3::Texture *t;
 
 		if (rt->external.fbo == 0) {
 			// create our fbo
@@ -3455,7 +2242,7 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 			bind_framebuffer(rt->external.fbo);
 
 			// allocate a texture
-			t = memnew(Texture);
+			t = memnew(GLES3::Texture);
 
 			t->type = RenderingDevice::TEXTURE_TYPE_2D;
 			t->flags = 0;
@@ -3478,14 +2265,14 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 			t->tex_id = 0;
 			t->render_target = rt;
 
-			rt->external.texture = texture_owner.make_rid(t);
+			rt->external.texture = GLES3::TextureStorage::get_singleton()->make_rid(t);
 
 		} else {
 			// bind our frame buffer
 			bind_framebuffer(rt->external.fbo);
 
 			// find our texture
-			t = texture_owner.get_or_null(rt->external.texture);
+			t = GLES3::TextureStorage::get_singleton()->get_texture(rt->external.texture);
 		}
 
 		// set our texture
@@ -3504,7 +2291,7 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, p_texture_id, 0);
 
 			// seeing we're rendering into this directly, better also use our depth buffer, just use our existing one :)
-			if (config.support_depth_texture) {
+			if (config->support_depth_texture) {
 				glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, rt->depth, 0);
 			} else {
 				glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, rt->depth);
@@ -3524,7 +2311,7 @@ void RasterizerStorageGLES3::render_target_set_external_texture(RID p_render_tar
 }
 
 void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target, RenderTargetFlags p_flag, bool p_value) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	// When setting DIRECT_TO_SCREEN, you need to clear before the value is set, but allocate after as
@@ -3556,21 +2343,21 @@ void RasterizerStorageGLES3::render_target_set_flag(RID p_render_target, RenderT
 }
 
 bool RasterizerStorageGLES3::render_target_was_used(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 
 	return rt->used_in_frame;
 }
 
 void RasterizerStorageGLES3::render_target_clear_used(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	rt->used_in_frame = false;
 }
 
 void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target, RS::ViewportMSAA p_msaa) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	if (rt->msaa == p_msaa) {
@@ -3582,20 +2369,20 @@ void RasterizerStorageGLES3::render_target_set_msaa(RID p_render_target, RS::Vie
 	_render_target_allocate(rt);
 }
 
-//RasterizerStorageGLES3::RenderTarget * RasterizerStorageGLES3::render_target_get(RID p_render_target)
+//RasterizerStorageGLES3::GLES3::RenderTarget * RasterizerStorageGLES3::render_target_get(RID p_render_target)
 //{
 //	return render_target_owner.get_or_null(p_render_target);
 //}
 
 void RasterizerStorageGLES3::render_target_set_use_fxaa(RID p_render_target, bool p_fxaa) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	rt->use_fxaa = p_fxaa;
 }
 
 void RasterizerStorageGLES3::render_target_set_use_debanding(RID p_render_target, bool p_debanding) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 
 	if (p_debanding) {
@@ -3606,7 +2393,7 @@ void RasterizerStorageGLES3::render_target_set_use_debanding(RID p_render_target
 }
 
 void RasterizerStorageGLES3::render_target_request_clear(RID p_render_target, const Color &p_clear_color) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = true;
 	rt->clear_color = p_clear_color;
@@ -3617,18 +2404,18 @@ void RasterizerStorageGLES3::render_target_request_clear(RID p_render_target, co
 }
 
 bool RasterizerStorageGLES3::render_target_is_clear_requested(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, false);
 	return rt->clear_requested;
 }
 Color RasterizerStorageGLES3::render_target_get_clear_request_color(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, Color());
 	return rt->clear_color;
 }
 
 void RasterizerStorageGLES3::render_target_disable_clear_request(RID p_render_target) {
-	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND(!rt);
 	rt->clear_requested = false;
 }
@@ -3651,8 +2438,8 @@ void RasterizerStorageGLES3::render_target_mark_sdf_enabled(RID p_render_target,
 RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
 	CanvasLightShadow *cls = memnew(CanvasLightShadow);
 
-	if (p_width > config.max_texture_size) {
-		p_width = config.max_texture_size;
+	if (p_width > config->max_texture_size) {
+		p_width = config->max_texture_size;
 	}
 
 	cls->size = p_width;
@@ -3665,12 +2452,12 @@ RID RasterizerStorageGLES3::canvas_light_shadow_buffer_create(int p_width) {
 
 	glGenRenderbuffers(1, &cls->depth);
 	glBindRenderbuffer(GL_RENDERBUFFER, cls->depth);
-	glRenderbufferStorage(GL_RENDERBUFFER, config.depth_buffer_internalformat, cls->size, cls->height);
+	glRenderbufferStorage(GL_RENDERBUFFER, config->depth_buffer_internalformat, cls->size, cls->height);
 	glFramebufferRenderbuffer(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_RENDERBUFFER, cls->depth);
 
 	glGenTextures(1, &cls->distance);
 	glBindTexture(GL_TEXTURE_2D, cls->distance);
-	if (config.use_rgba_2d_shadows) {
+	if (config->use_rgba_2d_shadows) {
 		glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, cls->size, cls->height, 0, GL_RGBA, GL_UNSIGNED_BYTE, nullptr);
 	} else {
 #ifdef GLES_OVER_GL
@@ -3822,33 +2609,23 @@ RS::InstanceType RasterizerStorageGLES3::get_base_type(RID p_rid) const {
 
 bool RasterizerStorageGLES3::free(RID p_rid) {
 	if (render_target_owner.owns(p_rid)) {
-		RenderTarget *rt = render_target_owner.get_or_null(p_rid);
+		GLES3::RenderTarget *rt = render_target_owner.get_or_null(p_rid);
 		_render_target_clear(rt);
 
-		Texture *t = texture_owner.get_or_null(rt->texture);
+		GLES3::Texture *t = GLES3::TextureStorage::get_singleton()->get_texture(rt->texture);
 		if (t) {
-			texture_owner.free(rt->texture);
+			GLES3::TextureStorage::get_singleton()->texture_free(rt->texture);
 			memdelete(t);
 		}
 		render_target_owner.free(p_rid);
 		memdelete(rt);
 
 		return true;
-	} else if (texture_owner.owns(p_rid)) {
-		Texture *t = texture_owner.get_or_null(p_rid);
-		// can't free a render target texture
-		ERR_FAIL_COND_V(t->render_target, true);
-		if (t->canvas_texture) {
-			memdelete(t->canvas_texture);
-		}
-
-		info.texture_mem -= t->total_data_size;
-		texture_owner.free(p_rid);
-		memdelete(t);
-
+	} else if (GLES3::TextureStorage::get_singleton()->owns_texture(p_rid)) {
+		GLES3::TextureStorage::get_singleton()->texture_free(p_rid);
 		return true;
-	} else if (canvas_texture_owner.owns(p_rid)) {
-		canvas_texture_owner.free(p_rid);
+	} else if (GLES3::CanvasTextureStorage::get_singleton()->owns_canvas_texture(p_rid)) {
+		GLES3::CanvasTextureStorage::get_singleton()->canvas_texture_free(p_rid);
 		return true;
 	} else if (sky_owner.owns(p_rid)) {
 		Sky *sky = sky_owner.get_or_null(p_rid);
@@ -4042,15 +2819,15 @@ bool RasterizerStorageGLES3::free(RID p_rid) {
 
 bool RasterizerStorageGLES3::has_os_feature(const String &p_feature) const {
 	if (p_feature == "s3tc") {
-		return config.s3tc_supported;
+		return config->s3tc_supported;
 	}
 
 	if (p_feature == "etc") {
-		return config.etc_supported;
+		return config->etc_supported;
 	}
 
 	if (p_feature == "skinning_fallback") {
-		return config.use_skeleton_software;
+		return config->use_skeleton_software;
 	}
 
 	return false;
@@ -4157,105 +2934,11 @@ RenderingDevice::DeviceType RasterizerStorageGLES3::get_video_adapter_type() con
 
 void RasterizerStorageGLES3::initialize() {
 	RasterizerStorageGLES3::system_fbo = 0;
+	config = GLES3::Config::get_singleton();
+	config->initialize();
 
-	{
-		const GLubyte *extension_string = glGetString(GL_EXTENSIONS);
-
-		Vector<String> extensions = String((const char *)extension_string).split(" ");
-
-		for (int i = 0; i < extensions.size(); i++) {
-			config.extensions.insert(extensions[i]);
-		}
-	}
-
-	config.keep_original_textures = true; // false
-	config.shrink_textures_x2 = false;
-	config.depth_internalformat = GL_DEPTH_COMPONENT;
-	config.depth_type = GL_UNSIGNED_INT;
-
-#ifdef GLES_OVER_GL
-	config.float_texture_supported = true;
-	config.s3tc_supported = true;
-	config.etc_supported = false;
-	config.support_npot_repeat_mipmap = true;
-	config.depth_buffer_internalformat = GL_DEPTH_COMPONENT24;
-#else
-	config.float_texture_supported = config.extensions.has("GL_ARB_texture_float") || config.extensions.has("GL_OES_texture_float");
-	config.s3tc_supported = config.extensions.has("GL_EXT_texture_compression_s3tc") || config.extensions.has("WEBGL_compressed_texture_s3tc");
-	config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture") || config.extensions.has("WEBGL_compressed_texture_etc1");
-	config.support_npot_repeat_mipmap = config.extensions.has("GL_OES_texture_npot");
-
-#ifdef JAVASCRIPT_ENABLED
-	// RenderBuffer internal format must be 16 bits in WebGL,
-	// but depth_texture should default to 32 always
-	// if the implementation doesn't support 32, it should just quietly use 16 instead
-	// https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/
-	config.depth_buffer_internalformat = GL_DEPTH_COMPONENT16;
-	config.depth_type = GL_UNSIGNED_INT;
-#else
-	// on mobile check for 24 bit depth support for RenderBufferStorage
-	if (config.extensions.has("GL_OES_depth24")) {
-		config.depth_buffer_internalformat = _DEPTH_COMPONENT24_OES;
-		config.depth_type = GL_UNSIGNED_INT;
-	} else {
-		config.depth_buffer_internalformat = GL_DEPTH_COMPONENT16;
-		config.depth_type = GL_UNSIGNED_SHORT;
-	}
-#endif
-#endif
-
-#ifdef GLES_OVER_GL
-	//TODO: causes huge problems with desktop video drivers. Making false for now, needs to be true to render SCREEN_TEXTURE mipmaps
-	config.render_to_mipmap_supported = false;
-#else
-	//check if mipmaps can be used for SCREEN_TEXTURE and Glow on Mobile and web platforms
-	config.render_to_mipmap_supported = config.extensions.has("GL_OES_fbo_render_mipmap") && config.extensions.has("GL_EXT_texture_lod");
-#endif
-
-#ifdef GLES_OVER_GL
-	config.use_rgba_2d_shadows = false;
-	config.support_depth_texture = true;
-	config.use_rgba_3d_shadows = false;
-	config.support_depth_cubemaps = true;
-#else
-	config.use_rgba_2d_shadows = !(config.float_texture_supported && config.extensions.has("GL_EXT_texture_rg"));
-	config.support_depth_texture = config.extensions.has("GL_OES_depth_texture") || config.extensions.has("WEBGL_depth_texture");
-	config.use_rgba_3d_shadows = !config.support_depth_texture;
-	config.support_depth_cubemaps = config.extensions.has("GL_OES_depth_texture_cube_map");
-#endif
-
-#ifdef GLES_OVER_GL
-	config.support_32_bits_indices = true;
-#else
-	config.support_32_bits_indices = config.extensions.has("GL_OES_element_index_uint");
-#endif
-
-#ifdef GLES_OVER_GL
-	config.support_write_depth = true;
-#elif defined(JAVASCRIPT_ENABLED)
-	config.support_write_depth = false;
-#else
-	config.support_write_depth = config.extensions.has("GL_EXT_frag_depth");
-#endif
-
-	config.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
-	config.support_half_float_vertices = false;
-#endif
-	bool disable_half_float = false; //GLOBAL_GET("rendering/opengl/compatibility/disable_half_float");
-	if (disable_half_float) {
-		config.support_half_float_vertices = false;
-	}
-
-	config.etc_supported = config.extensions.has("GL_OES_compressed_ETC1_RGB8_texture");
-	config.latc_supported = config.extensions.has("GL_EXT_texture_compression_latc");
-	config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc");
-	config.rgtc_supported = config.extensions.has("GL_EXT_texture_compression_rgtc") || config.extensions.has("GL_ARB_texture_compression_rgtc") || config.extensions.has("EXT_texture_compression_rgtc");
-	config.bptc_supported = config.extensions.has("GL_ARB_texture_compression_bptc") || config.extensions.has("EXT_texture_compression_bptc");
-	config.srgb_decode_supported = config.extensions.has("GL_EXT_texture_sRGB_decode");
 	//determine formats for depth textures (or renderbuffers)
-	if (config.support_depth_texture) {
+	if (config->support_depth_texture) {
 		// Will use texture for depth
 		// have to manually see if we can create a valid framebuffer texture using UNSIGNED_INT,
 		// as there is no extension to test for this.
@@ -4265,7 +2948,7 @@ void RasterizerStorageGLES3::initialize() {
 		GLuint depth;
 		glGenTextures(1, &depth);
 		glBindTexture(GL_TEXTURE_2D, depth);
-		glTexImage2D(GL_TEXTURE_2D, 0, config.depth_internalformat, 32, 32, 0, GL_DEPTH_COMPONENT, config.depth_type, nullptr);
+		glTexImage2D(GL_TEXTURE_2D, 0, config->depth_internalformat, 32, 32, 0, GL_DEPTH_COMPONENT, config->depth_type, nullptr);
 
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -4285,19 +2968,19 @@ void RasterizerStorageGLES3::initialize() {
 			// If it fails, test to see if it supports a framebuffer texture using UNSIGNED_SHORT
 			// This is needed because many OSX devices don't support either UNSIGNED_INT or UNSIGNED_SHORT
 #ifdef GLES_OVER_GL
-			config.depth_internalformat = GL_DEPTH_COMPONENT16;
+			config->depth_internalformat = GL_DEPTH_COMPONENT16;
 #else
 			// OES_depth_texture extension only specifies GL_DEPTH_COMPONENT.
-			config.depth_internalformat = GL_DEPTH_COMPONENT;
+			config->depth_internalformat = GL_DEPTH_COMPONENT;
 #endif
-			config.depth_type = GL_UNSIGNED_SHORT;
+			config->depth_type = GL_UNSIGNED_SHORT;
 
 			glGenFramebuffers(1, &fbo);
 			bind_framebuffer(fbo);
 
 			glGenTextures(1, &depth);
 			glBindTexture(GL_TEXTURE_2D, depth);
-			glTexImage2D(GL_TEXTURE_2D, 0, config.depth_internalformat, 32, 32, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, nullptr);
+			glTexImage2D(GL_TEXTURE_2D, 0, config->depth_internalformat, 32, 32, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_SHORT, nullptr);
 
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
 			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
@@ -4309,8 +2992,8 @@ void RasterizerStorageGLES3::initialize() {
 			status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 			if (status != GL_FRAMEBUFFER_COMPLETE) {
 				//if it fails again depth textures aren't supported, use rgba shadows and renderbuffer for depth
-				config.support_depth_texture = false;
-				config.use_rgba_3d_shadows = true;
+				config->support_depth_texture = false;
+				config->use_rgba_3d_shadows = true;
 			}
 
 			bind_framebuffer_system();
@@ -4321,20 +3004,16 @@ void RasterizerStorageGLES3::initialize() {
 	}
 
 	//picky requirements for these
-	config.support_shadow_cubemaps = config.support_depth_texture && config.support_write_depth && config.support_depth_cubemaps;
+	config->support_shadow_cubemaps = config->support_depth_texture && config->support_write_depth && config->support_depth_cubemaps;
 
 	frame.count = 0;
 	frame.delta = 0;
 	frame.current_rt = nullptr;
 	frame.clear_request = false;
 
-	glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &config.max_vertex_texture_image_units);
-	glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &config.max_texture_image_units);
-	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &config.max_texture_size);
-
 	// the use skeleton software path should be used if either float texture is not supported,
 	// OR max_vertex_texture_image_units is zero
-	config.use_skeleton_software = (config.float_texture_supported == false) || (config.max_vertex_texture_image_units == 0);
+	config->use_skeleton_software = (config->float_texture_supported == false) || (config->max_vertex_texture_image_units == 0);
 
 	shaders.copy.initialize();
 	shaders.copy_version = shaders.copy.version_create(); //TODO
@@ -4438,7 +3117,7 @@ void RasterizerStorageGLES3::initialize() {
 
 	// radical inverse vdc cache texture
 	// used for cubemap filtering
-	if (true /*||config.float_texture_supported*/) { //uint8 is similar and works everywhere
+	if (true /*||config->float_texture_supported*/) { //uint8 is similar and works everywhere
 		glGenTextures(1, &resources.radical_inverse_vdc_cache_tex);
 
 		glActiveTexture(GL_TEXTURE0);
@@ -4476,16 +3155,12 @@ void RasterizerStorageGLES3::initialize() {
 #ifdef GLES_OVER_GL
 	//this needs to be enabled manually in OpenGL 2.1
 
-	if (config.extensions.has("GL_ARB_seamless_cube_map")) {
+	if (config->extensions.has("GL_ARB_seamless_cube_map")) {
 		glEnable(_EXT_TEXTURE_CUBE_MAP_SEAMLESS);
 	}
 	glEnable(GL_POINT_SPRITE);
 	glEnable(GL_VERTEX_PROGRAM_POINT_SIZE);
 #endif
-
-	config.force_vertex_shading = false; //GLOBAL_GET("rendering/quality/shading/force_vertex_shading");
-	config.use_fast_texture_filter = false; //GLOBAL_GET("rendering/quality/filters/use_nearest_mipmap_filter");
-	//config.should_orphan = GLOBAL_GET("rendering/options/api_usage_legacy/orphan_buffers");
 }
 
 void RasterizerStorageGLES3::finalize() {
@@ -4512,7 +3187,6 @@ void RasterizerStorageGLES3::update_dirty_resources() {
 
 RasterizerStorageGLES3::RasterizerStorageGLES3() {
 	RasterizerStorageGLES3::system_fbo = 0;
-	config.should_orphan = true;
 }
 
 RasterizerStorageGLES3::~RasterizerStorageGLES3() {
diff --git a/drivers/gles3/rasterizer_storage_gles3.h b/drivers/gles3/rasterizer_storage_gles3.h
index de984fa8df..ba457e54b0 100644
--- a/drivers/gles3/rasterizer_storage_gles3.h
+++ b/drivers/gles3/rasterizer_storage_gles3.h
@@ -40,6 +40,10 @@
 #include "servers/rendering/renderer_storage.h"
 #include "servers/rendering/shader_compiler.h"
 #include "servers/rendering/shader_language.h"
+#include "storage/canvas_texture_storage.h"
+#include "storage/config.h"
+#include "storage/render_target_storage.h"
+#include "storage/texture_storage.h"
 
 #include "shaders/copy.glsl.gen.h"
 
@@ -47,66 +51,13 @@ class RasterizerCanvasGLES3;
 class RasterizerSceneGLES3;
 
 class RasterizerStorageGLES3 : public RendererStorage {
-	friend class RasterizerGLES3;
-
-	Thread::ID _main_thread_id = 0;
-	bool _is_main_thread();
-
 public:
 	RasterizerCanvasGLES3 *canvas;
 	RasterizerSceneGLES3 *scene;
 
 	static GLuint system_fbo;
 
-	struct Config {
-		bool shrink_textures_x2;
-		bool use_fast_texture_filter;
-		bool use_skeleton_software;
-
-		int max_vertex_texture_image_units;
-		int max_texture_image_units;
-		int max_texture_size;
-
-		// TODO implement wireframe in OpenGL
-		// bool generate_wireframes;
-
-		Set<String> extensions;
-
-		bool float_texture_supported;
-		bool s3tc_supported;
-		bool latc_supported;
-		bool rgtc_supported;
-		bool bptc_supported;
-		bool etc_supported;
-		bool etc2_supported;
-		bool srgb_decode_supported;
-
-		bool keep_original_textures;
-
-		bool force_vertex_shading;
-
-		bool use_rgba_2d_shadows;
-		bool use_rgba_3d_shadows;
-
-		bool support_32_bits_indices;
-		bool support_write_depth;
-		bool support_half_float_vertices;
-		bool support_npot_repeat_mipmap;
-		bool support_depth_texture;
-		bool support_depth_cubemaps;
-
-		bool support_shadow_cubemaps;
-
-		bool render_to_mipmap_supported;
-
-		GLuint depth_internalformat;
-		GLuint depth_type;
-		GLuint depth_buffer_internalformat;
-
-		// in some cases the legacy render didn't orphan. We will mark these
-		// so the user can switch orphaning off for them.
-		bool should_orphan;
-	} config;
+	GLES3::Config *config;
 
 	struct Resources {
 		GLuint white_tex;
@@ -180,334 +131,7 @@ public:
 	//////////////////////////////////API////////////////////////////////////////////////////
 	/////////////////////////////////////////////////////////////////////////////////////////
 
-	bool can_create_resources_async() const override;
-
-	// TEXTURE API
-
-	enum OpenGLTextureFlags {
-		TEXTURE_FLAG_MIPMAPS = 1, /// Enable automatic mipmap generation - when available
-		TEXTURE_FLAG_REPEAT = 2, /// Repeat texture (Tiling), otherwise Clamping
-		TEXTURE_FLAG_FILTER = 4, /// Create texture with linear (or available) filter
-		TEXTURE_FLAG_ANISOTROPIC_FILTER = 8,
-		TEXTURE_FLAG_CONVERT_TO_LINEAR = 16,
-		TEXTURE_FLAG_MIRRORED_REPEAT = 32, /// Repeat texture, with alternate sections mirrored
-		TEXTURE_FLAG_USED_FOR_STREAMING = 2048,
-		TEXTURE_FLAGS_DEFAULT = TEXTURE_FLAG_REPEAT | TEXTURE_FLAG_MIPMAPS | TEXTURE_FLAG_FILTER
-	};
-
-	/* CANVAS TEXTURE API (2D) */
-
-	struct CanvasTexture {
-		RID diffuse;
-		RID normal_map;
-		RID specular;
-		Color specular_color = Color(1, 1, 1, 1);
-		float shininess = 1.0;
-
-		RS::CanvasItemTextureFilter texture_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
-		RS::CanvasItemTextureRepeat texture_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
-
-		Size2i size_cache = Size2i(1, 1);
-		bool use_normal_cache = false;
-		bool use_specular_cache = false;
-		bool cleared_cache = true;
-	};
-
-	RID_Owner<CanvasTexture, true> canvas_texture_owner;
-
-	struct RenderTarget;
-
-	struct Texture {
-		RID self;
-
-		Texture *proxy;
-		Set<Texture *> proxy_owners;
-
-		String path;
-		uint32_t flags;
-		int width, height, depth;
-		int alloc_width, alloc_height;
-		Image::Format format;
-		RenderingDevice::TextureType type;
-
-		GLenum target;
-		GLenum gl_format_cache;
-		GLenum gl_internal_format_cache;
-		GLenum gl_type_cache;
-
-		int data_size;
-		int total_data_size;
-		bool ignore_mipmaps;
-
-		bool compressed;
-
-		bool srgb;
-
-		int mipmaps;
-
-		bool resize_to_po2;
-
-		bool active;
-		GLenum tex_id;
-
-		uint16_t stored_cube_sides;
-
-		RenderTarget *render_target;
-
-		Vector<Ref<Image>> images;
-
-		bool redraw_if_visible;
-
-		RS::TextureDetectCallback detect_3d;
-		void *detect_3d_ud;
-
-		RS::TextureDetectCallback detect_srgb;
-		void *detect_srgb_ud;
-
-		RS::TextureDetectCallback detect_normal;
-		void *detect_normal_ud;
-
-		CanvasTexture *canvas_texture = nullptr;
-
-		// some silly opengl shenanigans where
-		// texture coords start from bottom left, means we need to draw render target textures upside down
-		// to be compatible with vulkan etc.
-		bool is_upside_down() const {
-			if (proxy) {
-				return proxy->is_upside_down();
-			}
-
-			return render_target != nullptr;
-		}
-
-		Texture() {
-			create();
-		}
-
-		_ALWAYS_INLINE_ Texture *get_ptr() {
-			if (proxy) {
-				return proxy; //->get_ptr(); only one level of indirection, else not inlining possible.
-			} else {
-				return this;
-			}
-		}
-
-		~Texture() {
-			destroy();
-
-			if (tex_id != 0) {
-				glDeleteTextures(1, &tex_id);
-			}
-		}
-
-		void copy_from(const Texture &o) {
-			proxy = o.proxy;
-			flags = o.flags;
-			width = o.width;
-			height = o.height;
-			alloc_width = o.alloc_width;
-			alloc_height = o.alloc_height;
-			format = o.format;
-			type = o.type;
-			target = o.target;
-			data_size = o.data_size;
-			total_data_size = o.total_data_size;
-			ignore_mipmaps = o.ignore_mipmaps;
-			compressed = o.compressed;
-			mipmaps = o.mipmaps;
-			resize_to_po2 = o.resize_to_po2;
-			active = o.active;
-			tex_id = o.tex_id;
-			stored_cube_sides = o.stored_cube_sides;
-			render_target = o.render_target;
-			redraw_if_visible = o.redraw_if_visible;
-			detect_3d = o.detect_3d;
-			detect_3d_ud = o.detect_3d_ud;
-			detect_srgb = o.detect_srgb;
-			detect_srgb_ud = o.detect_srgb_ud;
-			detect_normal = o.detect_normal;
-			detect_normal_ud = o.detect_normal_ud;
-
-			images.clear();
-		}
-
-		void create() {
-			proxy = nullptr;
-			flags = 0;
-			width = 0;
-			height = 0;
-			alloc_width = 0;
-			alloc_height = 0;
-			format = Image::FORMAT_L8;
-			type = RenderingDevice::TEXTURE_TYPE_2D;
-			target = 0;
-			data_size = 0;
-			total_data_size = 0;
-			ignore_mipmaps = false;
-			compressed = false;
-			mipmaps = 0;
-			resize_to_po2 = false;
-			active = false;
-			tex_id = 0;
-			stored_cube_sides = 0;
-			render_target = nullptr;
-			redraw_if_visible = false;
-			detect_3d = nullptr;
-			detect_3d_ud = nullptr;
-			detect_srgb = nullptr;
-			detect_srgb_ud = nullptr;
-			detect_normal = nullptr;
-			detect_normal_ud = nullptr;
-		}
-		void destroy() {
-			images.clear();
-
-			for (Set<Texture *>::Element *E = proxy_owners.front(); E; E = E->next()) {
-				E->get()->proxy = nullptr;
-			}
-
-			if (proxy) {
-				proxy->proxy_owners.erase(this);
-			}
-		}
-
-		// texture state
-		void GLSetFilter(GLenum p_target, RS::CanvasItemTextureFilter p_filter) {
-			if (p_filter == state_filter) {
-				return;
-			}
-			state_filter = p_filter;
-			GLint pmin = GL_LINEAR; // param min
-			GLint pmag = GL_LINEAR; // param mag
-			switch (state_filter) {
-				default: {
-				} break;
-				case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS: {
-					pmin = GL_LINEAR_MIPMAP_LINEAR;
-					pmag = GL_LINEAR;
-				} break;
-				case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST: {
-					pmin = GL_NEAREST;
-					pmag = GL_NEAREST;
-				} break;
-				case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS: {
-					pmin = GL_NEAREST_MIPMAP_NEAREST;
-					pmag = GL_NEAREST;
-				} break;
-			}
-			glTexParameteri(p_target, GL_TEXTURE_MIN_FILTER, pmin);
-			glTexParameteri(p_target, GL_TEXTURE_MAG_FILTER, pmag);
-		}
-		void GLSetRepeat(GLenum p_target, RS::CanvasItemTextureRepeat p_repeat) {
-			if (p_repeat == state_repeat) {
-				return;
-			}
-			state_repeat = p_repeat;
-			GLint prep = GL_CLAMP_TO_EDGE; // parameter repeat
-			switch (state_repeat) {
-				default: {
-				} break;
-				case RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED: {
-					prep = GL_REPEAT;
-				} break;
-				case RS::CANVAS_ITEM_TEXTURE_REPEAT_MIRROR: {
-					prep = GL_MIRRORED_REPEAT;
-				} break;
-			}
-			glTexParameteri(p_target, GL_TEXTURE_WRAP_S, prep);
-			glTexParameteri(p_target, GL_TEXTURE_WRAP_T, prep);
-		}
-
-	private:
-		RS::CanvasItemTextureFilter state_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR;
-		RS::CanvasItemTextureRepeat state_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED;
-	};
-
-	mutable RID_PtrOwner<Texture> texture_owner;
-
-	Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, Image::Format &r_real_format, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool p_force_decompress) const;
-
-	void _texture_set_state_from_flags(Texture *p_tex);
-
-	// new
-	RID texture_allocate() override;
-	void texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) override;
-	void texture_2d_layered_initialize(RID p_texture, const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) override;
-	void texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) override;
-	void texture_proxy_initialize(RID p_texture, RID p_base) override; //all slices, then all the mipmaps, must be coherent
-
-	void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) override;
-	void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) override {}
-	void texture_proxy_update(RID p_proxy, RID p_base) override {}
-
-	void texture_2d_placeholder_initialize(RID p_texture) override;
-	void texture_2d_layered_placeholder_initialize(RID p_texture, RenderingServer::TextureLayeredType p_layered_type) override;
-	void texture_3d_placeholder_initialize(RID p_texture) override;
-
-	Ref<Image> texture_2d_get(RID p_texture) const override;
-	Ref<Image> texture_2d_layer_get(RID p_texture, int p_layer) const override { return Ref<Image>(); }
-	Vector<Ref<Image>> texture_3d_get(RID p_texture) const override { return Vector<Ref<Image>>(); }
-
-	void texture_replace(RID p_texture, RID p_by_texture) override;
-	//void texture_set_size_override(RID p_texture, int p_width, int p_height) override {}
-
-	void texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
-	void texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
-
-	// old
-	uint32_t texture_get_width(RID p_texture) const;
-	uint32_t texture_get_height(RID p_texture) const;
-
-private:
-	RID texture_create();
-
-	//void texture_allocate(RID p_texture, int p_width, int p_height, int p_depth_3d, Image::Format p_format, RenderingDevice::TextureType p_type, uint32_t p_flags = TEXTURE_FLAGS_DEFAULT);
-	void _texture_allocate_internal(RID p_texture, int p_width, int p_height, int p_depth_3d, Image::Format p_format, RenderingDevice::TextureType p_type, uint32_t p_flags = TEXTURE_FLAGS_DEFAULT);
-
-	void texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer = 0);
-	void texture_set_data_partial(RID p_texture, const Ref<Image> &p_image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int p_dst_mip, int p_layer = 0);
-	//Ref<Image> texture_get_data(RID p_texture, int p_layer = 0) const;
-	void texture_set_flags(RID p_texture, uint32_t p_flags);
-	uint32_t texture_get_flags(RID p_texture) const;
-	Image::Format texture_get_format(RID p_texture) const;
-	RenderingDevice::TextureType texture_get_type(RID p_texture) const;
-	uint32_t texture_get_texid(RID p_texture) const;
-	uint32_t texture_get_depth(RID p_texture) const;
-	void texture_set_size_override(RID p_texture, int p_width, int p_height) override;
-
-	void texture_bind(RID p_texture, uint32_t p_texture_no);
-
-	void texture_set_path(RID p_texture, const String &p_path) override;
-	String texture_get_path(RID p_texture) const override;
-
-	void texture_set_shrink_all_x2_on_set_data(bool p_enable);
-
-	void texture_debug_usage(List<RS::TextureInfo> *r_info) override;
-
-	RID texture_create_radiance_cubemap(RID p_source, int p_resolution = -1) const;
-
-	void textures_keep_original(bool p_enable);
-
-	void texture_set_proxy(RID p_texture, RID p_proxy);
-	Size2 texture_size_with_proxy(RID p_texture) override;
-
-	void texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
-	void texture_set_detect_srgb_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata);
-	void texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
-	void texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) override {}
-
-	void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) override;
-
 public:
-	RID canvas_texture_allocate() override;
-	void canvas_texture_initialize(RID p_rid) override;
-
-	void canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) override;
-	void canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) override;
-
-	void canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) override;
-	void canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) override;
-
 	/* SKY API */
 	// not sure if used in godot 4?
 	struct Sky {
@@ -971,6 +595,9 @@ public:
 
 	AABB decal_get_aabb(RID p_decal) const override;
 
+	void texture_add_to_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
+	void texture_remove_from_decal_atlas(RID p_texture, bool p_panorama_to_dp = false) override {}
+
 	/* VOXEL GI API */
 
 	RID voxel_gi_allocate() override;
@@ -1151,85 +778,10 @@ public:
 
 	// RENDER TARGET
 
-	struct RenderTarget {
-		RID self;
-		GLuint fbo = 0;
-		GLuint color = 0;
-		GLuint depth = 0;
-
-		GLuint multisample_fbo = 0;
-		GLuint multisample_color = 0;
-		GLuint multisample_depth = 0;
-		bool multisample_active = false;
-
-		struct Effect {
-			GLuint fbo = 0;
-			int width = 0;
-			int height = 0;
-
-			GLuint color = 0;
-		};
-
-		Effect copy_screen_effect;
-
-		struct MipMaps {
-			struct Size {
-				GLuint fbo = 0;
-				GLuint color = 0;
-				int width = 0;
-				int height = 0;
-			};
-
-			Vector<Size> sizes;
-			GLuint color = 0;
-			int levels = 0;
-		};
-
-		MipMaps mip_maps[2];
-
-		struct External {
-			GLuint fbo = 0;
-			GLuint color = 0;
-			GLuint depth = 0;
-			RID texture;
-		} external;
-
-		int x = 0;
-		int y = 0;
-		int width = 0;
-		int height = 0;
-
-		bool flags[RENDER_TARGET_FLAG_MAX] = {};
-
-		// instead of allocating sized render targets immediately,
-		// defer this for faster startup
-		bool allocate_is_dirty = false;
-		bool used_in_frame = false;
-		RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;
-
-		bool use_fxaa = false;
-		bool use_debanding = false;
-
-		RID texture;
-
-		bool used_dof_blur_near = false;
-		bool mip_maps_allocated = false;
-
-		Color clear_color = Color(1, 1, 1, 1);
-		bool clear_requested = false;
-
-		RenderTarget() {
-			for (int i = 0; i < RENDER_TARGET_FLAG_MAX; ++i) {
-				flags[i] = false;
-			}
-			external.fbo = 0;
-		}
-	};
-
-	mutable RID_PtrOwner<RenderTarget> render_target_owner;
+	mutable RID_PtrOwner<GLES3::RenderTarget> render_target_owner;
 
-	void _render_target_clear(RenderTarget *rt);
-	void _render_target_allocate(RenderTarget *rt);
+	void _render_target_clear(GLES3::RenderTarget *rt);
+	void _render_target_allocate(GLES3::RenderTarget *rt);
 	void _set_current_render_target(RID p_render_target);
 
 	RID render_target_create() override;
@@ -1262,7 +814,7 @@ public:
 	void render_target_mark_sdf_enabled(RID p_render_target, bool p_enabled) override;
 
 	// access from canvas
-	//	RenderTarget * render_target_get(RID p_render_target);
+	//	GLES3::RenderTarget * render_target_get(RID p_render_target);
 
 	/* CANVAS SHADOW */
 
@@ -1301,7 +853,7 @@ public:
 	bool free(RID p_rid) override;
 
 	struct Frame {
-		RenderTarget *current_rt;
+		GLES3::RenderTarget *current_rt;
 
 		// these 2 may have been superseded by the equivalents in the render target.
 		// these may be able to be removed.
@@ -1408,7 +960,7 @@ inline bool RasterizerStorageGLES3::safe_buffer_sub_data(unsigned int p_total_bu
 inline void RasterizerStorageGLES3::buffer_orphan_and_upload(unsigned int p_buffer_size, unsigned int p_offset, unsigned int p_data_size, const void *p_data, GLenum p_target, GLenum p_usage, bool p_optional_orphan) const {
 	// Orphan the buffer to avoid CPU/GPU sync points caused by glBufferSubData
 	// Was previously #ifndef GLES_OVER_GL however this causes stalls on desktop mac also (and possibly other)
-	if (!p_optional_orphan || (config.should_orphan)) {
+	if (!p_optional_orphan || (config->should_orphan)) {
 		glBufferData(p_target, p_buffer_size, nullptr, p_usage);
 #ifdef RASTERIZER_EXTRA_CHECKS
 		// fill with garbage off the end of the array
diff --git a/drivers/gles3/storage/SCsub b/drivers/gles3/storage/SCsub
new file mode 100644
index 0000000000..91e1140b75
--- /dev/null
+++ b/drivers/gles3/storage/SCsub
@@ -0,0 +1,5 @@
+#!/usr/bin/env python
+
+Import("env")
+
+env.add_source_files(env.drivers_sources, "*.cpp")
diff --git a/drivers/gles3/storage/canvas_texture_storage.cpp b/drivers/gles3/storage/canvas_texture_storage.cpp
new file mode 100644
index 0000000000..fe12700c21
--- /dev/null
+++ b/drivers/gles3/storage/canvas_texture_storage.cpp
@@ -0,0 +1,96 @@
+/*************************************************************************/
+/*  canvas_texture_storage.cpp                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifdef GLES3_ENABLED
+
+#include "canvas_texture_storage.h"
+
+using namespace GLES3;
+
+CanvasTextureStorage *CanvasTextureStorage::singleton = nullptr;
+
+CanvasTextureStorage *CanvasTextureStorage::get_singleton() {
+	return singleton;
+}
+
+CanvasTextureStorage::CanvasTextureStorage() {
+	singleton = this;
+}
+
+CanvasTextureStorage::~CanvasTextureStorage() {
+	singleton = nullptr;
+}
+
+RID CanvasTextureStorage::canvas_texture_allocate() {
+	return canvas_texture_owner.allocate_rid();
+}
+
+void CanvasTextureStorage::canvas_texture_initialize(RID p_rid) {
+	canvas_texture_owner.initialize_rid(p_rid);
+}
+
+void CanvasTextureStorage::canvas_texture_free(RID p_rid) {
+	canvas_texture_owner.free(p_rid);
+}
+
+void CanvasTextureStorage::canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) {
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
+	switch (p_channel) {
+		case RS::CANVAS_TEXTURE_CHANNEL_DIFFUSE: {
+			ct->diffuse = p_texture;
+		} break;
+		case RS::CANVAS_TEXTURE_CHANNEL_NORMAL: {
+			ct->normal_map = p_texture;
+		} break;
+		case RS::CANVAS_TEXTURE_CHANNEL_SPECULAR: {
+			ct->specular = p_texture;
+		} break;
+	}
+}
+
+void CanvasTextureStorage::canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_specular_color, float p_shininess) {
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
+	ct->specular_color.r = p_specular_color.r;
+	ct->specular_color.g = p_specular_color.g;
+	ct->specular_color.b = p_specular_color.b;
+	ct->specular_color.a = p_shininess;
+}
+
+void CanvasTextureStorage::canvas_texture_set_texture_filter(RID p_canvas_texture, RS::CanvasItemTextureFilter p_filter) {
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
+	ct->texture_filter = p_filter;
+}
+
+void CanvasTextureStorage::canvas_texture_set_texture_repeat(RID p_canvas_texture, RS::CanvasItemTextureRepeat p_repeat) {
+	CanvasTexture *ct = canvas_texture_owner.get_or_null(p_canvas_texture);
+	ct->texture_repeat = p_repeat;
+}
+
+#endif // !GLES3_ENABLED
diff --git a/drivers/gles3/storage/canvas_texture_storage.h b/drivers/gles3/storage/canvas_texture_storage.h
new file mode 100644
index 0000000000..5930e927fe
--- /dev/null
+++ b/drivers/gles3/storage/canvas_texture_storage.h
@@ -0,0 +1,87 @@
+/*************************************************************************/
+/*  canvas_texture_storage.h                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CANVAS_TEXTURE_STORAGE_GLES3_H
+#define CANVAS_TEXTURE_STORAGE_GLES3_H
+
+#ifdef GLES3_ENABLED
+
+#include "core/templates/rid_owner.h"
+#include "servers/rendering/storage/canvas_texture_storage.h"
+
+namespace GLES3 {
+
+struct CanvasTexture {
+	RID diffuse;
+	RID normal_map;
+	RID specular;
+	Color specular_color = Color(1, 1, 1, 1);
+	float shininess = 1.0;
+
+	RS::CanvasItemTextureFilter texture_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_DEFAULT;
+	RS::CanvasItemTextureRepeat texture_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DEFAULT;
+
+	Size2i size_cache = Size2i(1, 1);
+	bool use_normal_cache = false;
+	bool use_specular_cache = false;
+	bool cleared_cache = true;
+};
+
+class CanvasTextureStorage : public RendererCanvasTextureStorage {
+private:
+	static CanvasTextureStorage *singleton;
+
+	RID_Owner<CanvasTexture, true> canvas_texture_owner;
+
+public:
+	static CanvasTextureStorage *get_singleton();
+
+	CanvasTextureStorage();
+	virtual ~CanvasTextureStorage();
+
+	CanvasTexture *get_canvas_texture(RID p_rid) { return canvas_texture_owner.get_or_null(p_rid); };
+	bool owns_canvas_texture(RID p_rid) { return canvas_texture_owner.owns(p_rid); };
+
+	virtual RID canvas_texture_allocate() override;
+	virtual void canvas_texture_initialize(RID p_rid) override;
+	virtual void canvas_texture_free(RID p_rid) override;
+
+	virtual void canvas_texture_set_channel(RID p_canvas_texture, RS::CanvasTextureChannel p_channel, RID p_texture) override;
+	virtual void canvas_texture_set_shading_parameters(RID p_canvas_texture, const Color &p_base_color, float p_shininess) override;
+
+	virtual void canvas_texture_set_texture_filter(RID p_item, RS::CanvasItemTextureFilter p_filter) override;
+	virtual void canvas_texture_set_texture_repeat(RID p_item, RS::CanvasItemTextureRepeat p_repeat) override;
+};
+
+} // namespace GLES3
+
+#endif // !GLES3_ENABLED
+
+#endif // !CANVAS_TEXTURE_STORAGE_GLES3_H
diff --git a/drivers/gles3/storage/config.cpp b/drivers/gles3/storage/config.cpp
new file mode 100644
index 0000000000..1f66401427
--- /dev/null
+++ b/drivers/gles3/storage/config.cpp
@@ -0,0 +1,156 @@
+/*************************************************************************/
+/*  config.cpp                                                           */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifdef GLES3_ENABLED
+
+#include "config.h"
+#include "core/templates/vector.h"
+
+using namespace GLES3;
+
+Config *Config::singleton = nullptr;
+
+Config::Config() {
+	singleton = this;
+	should_orphan = true;
+}
+
+Config::~Config() {
+	singleton = nullptr;
+}
+
+void Config::initialize() {
+	{
+		const GLubyte *extension_string = glGetString(GL_EXTENSIONS);
+
+		Vector<String> exts = String((const char *)extension_string).split(" ");
+
+		for (int i = 0; i < exts.size(); i++) {
+			extensions.insert(exts[i]);
+		}
+	}
+
+	keep_original_textures = true; // false
+	shrink_textures_x2 = false;
+	depth_internalformat = GL_DEPTH_COMPONENT;
+	depth_type = GL_UNSIGNED_INT;
+
+#ifdef GLES_OVER_GL
+	float_texture_supported = true;
+	s3tc_supported = true;
+	etc_supported = false;
+	support_npot_repeat_mipmap = true;
+	depth_buffer_internalformat = GL_DEPTH_COMPONENT24;
+#else
+	float_texture_supported = extensions.has("GL_ARB_texture_float") || extensions.has("GL_OES_texture_float");
+	s3tc_supported = extensions.has("GL_EXT_texture_compression_s3tc") || extensions.has("WEBGL_compressed_texture_s3tc");
+	etc_supported = extensions.has("GL_OES_compressed_ETC1_RGB8_texture") || extensions.has("WEBGL_compressed_texture_etc1");
+	support_npot_repeat_mipmap = extensions.has("GL_OES_texture_npot");
+
+#ifdef JAVASCRIPT_ENABLED
+	// RenderBuffer internal format must be 16 bits in WebGL,
+	// but depth_texture should default to 32 always
+	// if the implementation doesn't support 32, it should just quietly use 16 instead
+	// https://www.khronos.org/registry/webgl/extensions/WEBGL_depth_texture/
+	depth_buffer_internalformat = GL_DEPTH_COMPONENT16;
+	depth_type = GL_UNSIGNED_INT;
+#else
+	// on mobile check for 24 bit depth support for RenderBufferStorage
+	if (extensions.has("GL_OES_depth24")) {
+		depth_buffer_internalformat = _DEPTH_COMPONENT24_OES;
+		depth_type = GL_UNSIGNED_INT;
+	} else {
+		depth_buffer_internalformat = GL_DEPTH_COMPONENT16;
+		depth_type = GL_UNSIGNED_SHORT;
+	}
+#endif
+#endif
+
+#ifdef GLES_OVER_GL
+	//TODO: causes huge problems with desktop video drivers. Making false for now, needs to be true to render SCREEN_TEXTURE mipmaps
+	render_to_mipmap_supported = false;
+#else
+	//check if mipmaps can be used for SCREEN_TEXTURE and Glow on Mobile and web platforms
+	render_to_mipmap_supported = extensions.has("GL_OES_fbo_render_mipmap") && extensions.has("GL_EXT_texture_lod");
+#endif
+
+#ifdef GLES_OVER_GL
+	use_rgba_2d_shadows = false;
+	support_depth_texture = true;
+	use_rgba_3d_shadows = false;
+	support_depth_cubemaps = true;
+#else
+	use_rgba_2d_shadows = !(float_texture_supported && extensions.has("GL_EXT_texture_rg"));
+	support_depth_texture = extensions.has("GL_OES_depth_texture") || extensions.has("WEBGL_depth_texture");
+	use_rgba_3d_shadows = !support_depth_texture;
+	support_depth_cubemaps = extensions.has("GL_OES_depth_texture_cube_map");
+#endif
+
+#ifdef GLES_OVER_GL
+	support_32_bits_indices = true;
+#else
+	support_32_bits_indices = extensions.has("GL_OES_element_index_uint");
+#endif
+
+#ifdef GLES_OVER_GL
+	support_write_depth = true;
+#elif defined(JAVASCRIPT_ENABLED)
+	support_write_depth = false;
+#else
+	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;
+	}
+
+	etc_supported = extensions.has("GL_OES_compressed_ETC1_RGB8_texture");
+	latc_supported = extensions.has("GL_EXT_texture_compression_latc");
+	bptc_supported = extensions.has("GL_ARB_texture_compression_bptc");
+	rgtc_supported = extensions.has("GL_EXT_texture_compression_rgtc") || extensions.has("GL_ARB_texture_compression_rgtc") || extensions.has("EXT_texture_compression_rgtc");
+	bptc_supported = extensions.has("GL_ARB_texture_compression_bptc") || extensions.has("EXT_texture_compression_bptc");
+	srgb_decode_supported = extensions.has("GL_EXT_texture_sRGB_decode");
+
+	glGetIntegerv(GL_MAX_VERTEX_TEXTURE_IMAGE_UNITS, &max_vertex_texture_image_units);
+	glGetIntegerv(GL_MAX_COMBINED_TEXTURE_IMAGE_UNITS, &max_texture_image_units);
+	glGetIntegerv(GL_MAX_TEXTURE_SIZE, &max_texture_size);
+
+	force_vertex_shading = false; //GLOBAL_GET("rendering/quality/shading/force_vertex_shading");
+	use_fast_texture_filter = false; //GLOBAL_GET("rendering/quality/filters/use_nearest_mipmap_filter");
+	// should_orphan = GLOBAL_GET("rendering/options/api_usage_legacy/orphan_buffers");
+}
+
+#endif // GLES3_ENABLED
diff --git a/drivers/gles3/storage/config.h b/drivers/gles3/storage/config.h
new file mode 100644
index 0000000000..25bd3fd9a1
--- /dev/null
+++ b/drivers/gles3/storage/config.h
@@ -0,0 +1,113 @@
+/*************************************************************************/
+/*  config.h                                                             */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef CONFIG_GLES3_H
+#define CONFIG_GLES3_H
+
+#ifdef GLES3_ENABLED
+
+#include "core/string/ustring.h"
+#include "core/templates/set.h"
+
+// This must come first to avoid windows.h mess
+#include "platform_config.h"
+#ifndef OPENGL_INCLUDE_H
+#include <GLES3/gl3.h>
+#else
+#include OPENGL_INCLUDE_H
+#endif
+
+namespace GLES3 {
+
+class Config {
+private:
+	static Config *singleton;
+
+public:
+	bool shrink_textures_x2;
+	bool use_fast_texture_filter;
+	bool use_skeleton_software;
+
+	int max_vertex_texture_image_units;
+	int max_texture_image_units;
+	int max_texture_size;
+
+	// TODO implement wireframe in OpenGL
+	// bool generate_wireframes;
+
+	Set<String> extensions;
+
+	bool float_texture_supported;
+	bool s3tc_supported;
+	bool latc_supported;
+	bool rgtc_supported;
+	bool bptc_supported;
+	bool etc_supported;
+	bool etc2_supported;
+	bool srgb_decode_supported;
+
+	bool keep_original_textures;
+
+	bool force_vertex_shading;
+
+	bool use_rgba_2d_shadows;
+	bool use_rgba_3d_shadows;
+
+	bool support_32_bits_indices;
+	bool support_write_depth;
+	bool support_half_float_vertices;
+	bool support_npot_repeat_mipmap;
+	bool support_depth_texture;
+	bool support_depth_cubemaps;
+
+	bool support_shadow_cubemaps;
+
+	bool render_to_mipmap_supported;
+
+	GLuint depth_internalformat;
+	GLuint depth_type;
+	GLuint depth_buffer_internalformat;
+
+	// in some cases the legacy render didn't orphan. We will mark these
+	// so the user can switch orphaning off for them.
+	bool should_orphan = true;
+
+	static Config *get_singleton() { return singleton; };
+
+	Config();
+	~Config();
+	void initialize();
+};
+
+} // namespace GLES3
+
+#endif // GLES3_ENABLED
+
+#endif // !CONFIG_GLES3_H
diff --git a/drivers/gles3/storage/render_target_storage.h b/drivers/gles3/storage/render_target_storage.h
new file mode 100644
index 0000000000..816cc76e40
--- /dev/null
+++ b/drivers/gles3/storage/render_target_storage.h
@@ -0,0 +1,132 @@
+/*************************************************************************/
+/*  render_target_storage.h                                              */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef RENDER_TARGET_STORAGE_GLES3_H
+#define RENDER_TARGET_STORAGE_GLES3_H
+
+#ifdef GLES3_ENABLED
+
+#include "core/templates/rid_owner.h"
+#include "servers/rendering/renderer_compositor.h"
+#include "servers/rendering/renderer_storage.h" // included until we move stuff into storage/render_target_storage.h
+// #include "servers/rendering/storage/render_target_storage.h"
+
+// This must come first to avoid windows.h mess
+#include "platform_config.h"
+#ifndef OPENGL_INCLUDE_H
+#include <GLES3/gl3.h>
+#else
+#include OPENGL_INCLUDE_H
+#endif
+
+namespace GLES3 {
+
+// NOTE, this class currently is just a container for the the RenderTarget struct and is not yet implemented further, we'll do that next after we finish with TextureStorage
+
+struct RenderTarget {
+	RID self;
+	GLuint fbo = 0;
+	GLuint color = 0;
+	GLuint depth = 0;
+
+	GLuint multisample_fbo = 0;
+	GLuint multisample_color = 0;
+	GLuint multisample_depth = 0;
+	bool multisample_active = false;
+
+	struct Effect {
+		GLuint fbo = 0;
+		int width = 0;
+		int height = 0;
+
+		GLuint color = 0;
+	};
+
+	Effect copy_screen_effect;
+
+	struct MipMaps {
+		struct Size {
+			GLuint fbo = 0;
+			GLuint color = 0;
+			int width = 0;
+			int height = 0;
+		};
+
+		Vector<Size> sizes;
+		GLuint color = 0;
+		int levels = 0;
+	};
+
+	MipMaps mip_maps[2];
+
+	struct External {
+		GLuint fbo = 0;
+		GLuint color = 0;
+		GLuint depth = 0;
+		RID texture;
+	} external;
+
+	int x = 0;
+	int y = 0;
+	int width = 0;
+	int height = 0;
+
+	bool flags[RendererStorage::RENDER_TARGET_FLAG_MAX] = {};
+
+	// instead of allocating sized render targets immediately,
+	// defer this for faster startup
+	bool allocate_is_dirty = false;
+	bool used_in_frame = false;
+	RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;
+
+	bool use_fxaa = false;
+	bool use_debanding = false;
+
+	RID texture;
+
+	bool used_dof_blur_near = false;
+	bool mip_maps_allocated = false;
+
+	Color clear_color = Color(1, 1, 1, 1);
+	bool clear_requested = false;
+
+	RenderTarget() {
+		for (int i = 0; i < RendererStorage::RENDER_TARGET_FLAG_MAX; ++i) {
+			flags[i] = false;
+		}
+		external.fbo = 0;
+	}
+};
+
+} // namespace GLES3
+
+#endif // !GLES3_ENABLED
+
+#endif // !RENDER_TARGET_STORAGE_GLES3_H
diff --git a/drivers/gles3/storage/texture_storage.cpp b/drivers/gles3/storage/texture_storage.cpp
new file mode 100644
index 0000000000..d199b1032e
--- /dev/null
+++ b/drivers/gles3/storage/texture_storage.cpp
@@ -0,0 +1,1211 @@
+/*************************************************************************/
+/*  texture_storage.cpp                                                  */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifdef GLES3_ENABLED
+
+#include "texture_storage.h"
+#include "config.h"
+
+using namespace GLES3;
+
+TextureStorage *TextureStorage::singleton = nullptr;
+
+TextureStorage *TextureStorage::get_singleton() {
+	return singleton;
+}
+
+TextureStorage::TextureStorage() {
+	singleton = this;
+}
+
+TextureStorage::~TextureStorage() {
+	singleton = nullptr;
+}
+
+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;
+}
+
+bool TextureStorage::can_create_resources_async() const {
+	return false;
+}
+
+static const GLenum _cube_side_enum[6] = {
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_X,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_X,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Y,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Y,
+	GL_TEXTURE_CUBE_MAP_NEGATIVE_Z,
+	GL_TEXTURE_CUBE_MAP_POSITIVE_Z,
+};
+
+Ref<Image> TextureStorage::_get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, Image::Format &r_real_format, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool p_force_decompress) const {
+	Config *config = Config::get_singleton();
+	r_gl_format = 0;
+	Ref<Image> image = p_image;
+	r_compressed = false;
+	r_real_format = p_format;
+
+	bool need_decompress = false;
+
+	switch (p_format) {
+		case Image::FORMAT_L8: {
+#ifdef GLES_OVER_GL
+			r_gl_internal_format = GL_R8;
+			r_gl_format = GL_RED;
+			r_gl_type = GL_UNSIGNED_BYTE;
+#else
+			r_gl_internal_format = GL_LUMINANCE;
+			r_gl_format = GL_LUMINANCE;
+			r_gl_type = GL_UNSIGNED_BYTE;
+#endif
+		} break;
+		case Image::FORMAT_LA8: {
+#ifdef GLES_OVER_GL
+			r_gl_internal_format = GL_RG8;
+			r_gl_format = GL_RG;
+			r_gl_type = GL_UNSIGNED_BYTE;
+#else
+			r_gl_internal_format = GL_LUMINANCE_ALPHA;
+			r_gl_format = GL_LUMINANCE_ALPHA;
+			r_gl_type = GL_UNSIGNED_BYTE;
+#endif
+		} break;
+		case Image::FORMAT_R8: {
+			r_gl_internal_format = GL_R8;
+			r_gl_format = GL_RED;
+			r_gl_type = GL_UNSIGNED_BYTE;
+
+		} break;
+		case Image::FORMAT_RG8: {
+			r_gl_internal_format = GL_RG8;
+			r_gl_format = GL_RG;
+			r_gl_type = GL_UNSIGNED_BYTE;
+
+		} break;
+		case Image::FORMAT_RGB8: {
+			r_gl_internal_format = GL_RGB8;
+			r_gl_format = GL_RGB;
+			r_gl_type = GL_UNSIGNED_BYTE;
+			//r_srgb = true;
+
+		} break;
+		case Image::FORMAT_RGBA8: {
+			r_gl_format = GL_RGBA;
+			r_gl_internal_format = GL_RGBA8;
+			r_gl_type = GL_UNSIGNED_BYTE;
+			//r_srgb = true;
+
+		} break;
+		case Image::FORMAT_RGBA4444: {
+			r_gl_internal_format = GL_RGBA4;
+			r_gl_format = GL_RGBA;
+			r_gl_type = GL_UNSIGNED_SHORT_4_4_4_4;
+
+		} break;
+			//case Image::FORMAT_RGBA5551: {
+			//	r_gl_internal_format = GL_RGB5_A1;
+			//	r_gl_format = GL_RGBA;
+			//	r_gl_type = GL_UNSIGNED_SHORT_5_5_5_1;
+			//
+			//} break;
+		case Image::FORMAT_RF: {
+			r_gl_internal_format = GL_R32F;
+			r_gl_format = GL_RED;
+			r_gl_type = GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGF: {
+			r_gl_internal_format = GL_RG32F;
+			r_gl_format = GL_RG;
+			r_gl_type = GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBF: {
+			r_gl_internal_format = GL_RGB32F;
+			r_gl_format = GL_RGB;
+			r_gl_type = GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBAF: {
+			r_gl_internal_format = GL_RGBA32F;
+			r_gl_format = GL_RGBA;
+			r_gl_type = GL_FLOAT;
+
+		} break;
+		case Image::FORMAT_RH: {
+			r_gl_internal_format = GL_R16F;
+			r_gl_format = GL_RED;
+			r_gl_type = GL_HALF_FLOAT;
+		} break;
+		case Image::FORMAT_RGH: {
+			r_gl_internal_format = GL_RG16F;
+			r_gl_format = GL_RG;
+			r_gl_type = GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBH: {
+			r_gl_internal_format = GL_RGB16F;
+			r_gl_format = GL_RGB;
+			r_gl_type = GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBAH: {
+			r_gl_internal_format = GL_RGBA16F;
+			r_gl_format = GL_RGBA;
+			r_gl_type = GL_HALF_FLOAT;
+
+		} break;
+		case Image::FORMAT_RGBE9995: {
+			r_gl_internal_format = GL_RGB9_E5;
+			r_gl_format = GL_RGB;
+			r_gl_type = GL_UNSIGNED_INT_5_9_9_9_REV;
+
+		} break;
+		case Image::FORMAT_DXT1: {
+			if (config->s3tc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_DXT3: {
+			if (config->s3tc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_DXT5: {
+			if (config->s3tc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_RGTC_R: {
+			if (config->rgtc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RED_RGTC1_EXT;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_RGTC_RG: {
+			if (config->rgtc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_BPTC_RGBA: {
+			if (config->bptc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGBA_BPTC_UNORM;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_BPTC_RGBF: {
+			if (config->bptc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT;
+				r_gl_format = GL_RGB;
+				r_gl_type = GL_FLOAT;
+				r_compressed = true;
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_BPTC_RGBFU: {
+			if (config->bptc_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT;
+				r_gl_format = GL_RGB;
+				r_gl_type = GL_FLOAT;
+				r_compressed = true;
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC: {
+			if (config->etc_supported) {
+				r_gl_internal_format = _EXT_ETC1_RGB8_OES;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+
+		} break;
+		/*
+		case Image::FORMAT_ETC2_R11: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_R11_EAC;
+				r_gl_format = GL_RED;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_R11S: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_SIGNED_R11_EAC;
+				r_gl_format = GL_RED;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RG11: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RG11_EAC;
+				r_gl_format = GL_RG;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RG11S: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_SIGNED_RG11_EAC;
+				r_gl_format = GL_RG;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGB8: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGB8_ETC2;
+				r_gl_format = GL_RGB;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGBA8: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGBA8_ETC2_EAC;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		case Image::FORMAT_ETC2_RGB8A1: {
+			if (config->etc2_supported) {
+				r_gl_internal_format = _EXT_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2;
+				r_gl_format = GL_RGBA;
+				r_gl_type = GL_UNSIGNED_BYTE;
+				r_compressed = true;
+				//r_srgb = true;
+
+			} else {
+				need_decompress = true;
+			}
+		} break;
+		*/
+		default: {
+			ERR_FAIL_V(Ref<Image>());
+		}
+	}
+
+	if (need_decompress || p_force_decompress) {
+		if (!image.is_null()) {
+			image = image->duplicate();
+			image->decompress();
+			ERR_FAIL_COND_V(image->is_compressed(), image);
+			switch (image->get_format()) {
+				case Image::FORMAT_RGB8: {
+					r_gl_format = GL_RGB;
+					r_gl_internal_format = GL_RGB;
+					r_gl_type = GL_UNSIGNED_BYTE;
+					r_real_format = Image::FORMAT_RGB8;
+					r_compressed = false;
+				} break;
+				case Image::FORMAT_RGBA8: {
+					r_gl_format = GL_RGBA;
+					r_gl_internal_format = GL_RGBA;
+					r_gl_type = GL_UNSIGNED_BYTE;
+					r_real_format = Image::FORMAT_RGBA8;
+					r_compressed = false;
+				} break;
+				default: {
+					image->convert(Image::FORMAT_RGBA8);
+					r_gl_format = GL_RGBA;
+					r_gl_internal_format = GL_RGBA;
+					r_gl_type = GL_UNSIGNED_BYTE;
+					r_real_format = Image::FORMAT_RGBA8;
+					r_compressed = false;
+
+				} break;
+			}
+		}
+
+		return image;
+	}
+
+	return p_image;
+}
+
+void TextureStorage::_texture_set_state_from_flags(Texture *p_tex) {
+	// Config *config = Config::get_singleton();
+
+	if ((p_tex->flags & TEXTURE_FLAG_MIPMAPS) && !p_tex->ignore_mipmaps) {
+		if (p_tex->flags & TEXTURE_FLAG_FILTER) {
+			// these do not exactly correspond ...
+			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS);
+			//texture->glTexParam_MinFilter(texture->target, config->use_fast_texture_filter ? GL_LINEAR_MIPMAP_NEAREST : GL_LINEAR_MIPMAP_LINEAR);
+		} else {
+			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS);
+			//texture->glTexParam_MinFilter(texture->target, config->use_fast_texture_filter ? GL_NEAREST_MIPMAP_NEAREST : GL_NEAREST_MIPMAP_LINEAR);
+		}
+	} else {
+		if (p_tex->flags & TEXTURE_FLAG_FILTER) {
+			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR);
+			//texture->glTexParam_MinFilter(texture->target, GL_LINEAR);
+		} else {
+			p_tex->GLSetFilter(p_tex->target, RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST);
+			//texture->glTexParam_MinFilter(texture->target, GL_NEAREST);
+		}
+	}
+
+	if (((p_tex->flags & TEXTURE_FLAG_REPEAT) || (p_tex->flags & TEXTURE_FLAG_MIRRORED_REPEAT)) && p_tex->target != GL_TEXTURE_CUBE_MAP) {
+		if (p_tex->flags & TEXTURE_FLAG_MIRRORED_REPEAT) {
+			p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_MIRROR);
+		} else {
+			p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED);
+		}
+	} else {
+		p_tex->GLSetRepeat(p_tex->target, RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED);
+	}
+}
+
+void TextureStorage::_texture_allocate_internal(RID p_texture, int p_width, int p_height, int p_depth_3d, Image::Format p_format, RenderingDevice::TextureType p_type, uint32_t p_flags) {
+	//	GLenum format;
+	//	GLenum internal_format;
+	//	GLenum type;
+
+	//	bool compressed = false;
+
+	// Config *config = Config::get_singleton();
+
+	if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
+		p_flags &= ~TEXTURE_FLAG_MIPMAPS; // no mipies for video
+	}
+
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+	texture->width = p_width;
+	texture->height = p_height;
+	texture->format = p_format;
+	texture->flags = p_flags;
+	texture->stored_cube_sides = 0;
+	texture->type = p_type;
+
+	switch (p_type) {
+		case RenderingDevice::TEXTURE_TYPE_2D: {
+			texture->target = GL_TEXTURE_2D;
+			texture->images.resize(1);
+		} break;
+			//		case RenderingDevice::TEXTURE_TYPE_EXTERNAL: {
+			//#ifdef ANDROID_ENABLED
+			//			texture->target = _GL_TEXTURE_EXTERNAL_OES;
+			//#else
+			//			texture->target = GL_TEXTURE_2D;
+			//#endif
+			//			texture->images.resize(0);
+			//		} break;
+		case RenderingDevice::TEXTURE_TYPE_CUBE: {
+			texture->target = GL_TEXTURE_CUBE_MAP;
+			texture->images.resize(6);
+		} break;
+		case RenderingDevice::TEXTURE_TYPE_2D_ARRAY:
+		case RenderingDevice::TEXTURE_TYPE_3D: {
+			texture->target = GL_TEXTURE_3D;
+			ERR_PRINT("3D textures and Texture Arrays are not supported in OpenGL. Please switch to the Vulkan backend.");
+			return;
+		} break;
+		default: {
+			ERR_PRINT("Unknown texture type!");
+			return;
+		}
+	}
+
+#if 0
+	//		if (p_type != RS::TEXTURE_TYPE_EXTERNAL) {
+	if (p_type == RenderingDevice::TEXTURE_TYPE_2D) {
+		texture->alloc_width = texture->width;
+		texture->alloc_height = texture->height;
+		texture->resize_to_po2 = false;
+		if (!config->support_npot_repeat_mipmap) {
+			int po2_width = next_power_of_2(p_width);
+			int po2_height = next_power_of_2(p_height);
+
+			bool is_po2 = p_width == po2_width && p_height == po2_height;
+
+			if (!is_po2 && (p_flags & TEXTURE_FLAG_REPEAT || p_flags & TEXTURE_FLAG_MIPMAPS)) {
+				if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
+					//not supported
+					ERR_PRINT("Streaming texture for non power of 2 or has mipmaps on this hardware: " + texture->path + "'. Mipmaps and repeat disabled.");
+					texture->flags &= ~(TEXTURE_FLAG_REPEAT | TEXTURE_FLAG_MIPMAPS);
+				} else {
+					texture->alloc_height = po2_height;
+					texture->alloc_width = po2_width;
+					texture->resize_to_po2 = true;
+				}
+			}
+		}
+
+		GLenum format;
+		GLenum internal_format;
+		GLenum type;
+		bool compressed = false;
+
+		Image::Format real_format;
+		_get_gl_image_and_format(Ref<Image>(),
+				texture->format,
+				texture->flags,
+				real_format,
+				format,
+				internal_format,
+				type,
+				compressed,
+				texture->resize_to_po2);
+
+		texture->gl_format_cache = format;
+		texture->gl_type_cache = type;
+		texture->gl_internal_format_cache = internal_format;
+		texture->data_size = 0;
+		texture->mipmaps = 1;
+
+		texture->compressed = compressed;
+	}
+#endif
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	//	if (p_type == RS::TEXTURE_TYPE_EXTERNAL) {
+	//		glTexParameteri(texture->target, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	//		glTexParameteri(texture->target, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	//		glTexParameteri(texture->target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+	//		glTexParameteri(texture->target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+	//	} else if (p_flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
+	//		//prealloc if video
+	//		glTexImage2D(texture->target, 0, internal_format, texture->alloc_width, texture->alloc_height, 0, format, type, NULL);
+	//	}
+
+	texture->active = true;
+}
+
+RID TextureStorage::texture_create() {
+	ERR_FAIL_COND_V(!_is_main_thread(), RID());
+
+	Texture *texture = memnew(Texture);
+	ERR_FAIL_COND_V(!texture, RID());
+	glGenTextures(1, &texture->tex_id);
+	texture->active = false;
+	texture->total_data_size = 0;
+
+	return texture_owner.make_rid(texture);
+}
+
+RID TextureStorage::texture_allocate() {
+	RID id = texture_create();
+	ERR_FAIL_COND_V(id == RID(), id);
+	return id;
+}
+
+void TextureStorage::texture_free(RID p_rid) {
+	Texture *t = texture_owner.get_or_null(p_rid);
+
+	// can't free a render target texture
+	ERR_FAIL_COND(t->render_target);
+	if (t->canvas_texture) {
+		memdelete(t->canvas_texture);
+	}
+
+	// info.texture_mem -= t->total_data_size; // TODO make this work again!!
+	texture_owner.free(p_rid);
+	memdelete(t);
+}
+
+void TextureStorage::texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) {
+	Texture *tex = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!tex);
+
+	int w = p_image->get_width();
+	int h = p_image->get_height();
+
+	_texture_allocate_internal(p_texture, w, h, 1, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D, 0);
+	texture_set_data(p_texture, p_image);
+}
+
+void TextureStorage::texture_2d_layered_initialize(RID p_texture, const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
+}
+
+void TextureStorage::texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) {
+}
+
+void TextureStorage::texture_proxy_initialize(RID p_texture, RID p_base) {
+	texture_set_proxy(p_texture, p_base);
+}
+
+//RID TextureStorage::texture_2d_create(const Ref<Image> &p_image) {
+//	RID id = texture_create();
+//	ERR_FAIL_COND_V(id == RID(), id);
+
+//	int w = p_image->get_width();
+//	int h = p_image->get_height();
+
+//	texture_allocate(id, w, h, 1, p_image->get_format(), RenderingDevice::TEXTURE_TYPE_2D, 0);
+
+//	texture_set_data(id, p_image);
+
+//	return id;
+//}
+
+//RID TextureStorage::texture_2d_layered_create(const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) {
+//	return RID();
+//}
+
+//void TextureStorage::texture_2d_update_immediate(RID p_texture, const Ref<Image> &p_image, int p_layer) {
+//	// only 1 layer so far
+//	texture_set_data(p_texture, p_image);
+//}
+
+void TextureStorage::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {
+	// only 1 layer so far
+	texture_set_data(p_texture, p_image);
+}
+
+void TextureStorage::texture_2d_placeholder_initialize(RID p_texture) {
+}
+
+void TextureStorage::texture_2d_layered_placeholder_initialize(RID p_texture, RenderingServer::TextureLayeredType p_layered_type) {
+}
+
+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>());
+
+	/*
+#ifdef TOOLS_ENABLED
+	if (tex->image_cache_2d.is_valid()) {
+		return tex->image_cache_2d;
+	}
+#endif
+	Vector<uint8_t> data = RD::get_singleton()->texture_get_data(tex->rd_texture, 0);
+	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);
+	}
+
+#ifdef TOOLS_ENABLED
+	if (Engine::get_singleton()->is_editor_hint()) {
+		tex->image_cache_2d = image;
+	}
+#endif
+*/
+	ERR_FAIL_COND_V(!tex->images.size(), Ref<Image>());
+
+	return tex->images[0];
+
+	//	return image;
+
+	//	return Ref<Image>();
+}
+
+void TextureStorage::texture_replace(RID p_texture, RID p_by_texture) {
+	Texture *tex_to = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!tex_to);
+	Texture *tex_from = texture_owner.get_or_null(p_by_texture);
+	ERR_FAIL_COND(!tex_from);
+
+	tex_to->destroy();
+	tex_to->copy_from(*tex_from);
+
+	// copy image data and upload to GL
+	tex_to->images.resize(tex_from->images.size());
+
+	for (int n = 0; n < tex_from->images.size(); n++) {
+		texture_set_data(p_texture, tex_from->images[n], n);
+	}
+
+	texture_free(p_by_texture);
+}
+
+void TextureStorage::texture_set_size_override(RID p_texture, int p_width, int p_height) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND(!texture);
+	ERR_FAIL_COND(texture->render_target);
+
+	ERR_FAIL_COND(p_width <= 0 || p_width > 16384);
+	ERR_FAIL_COND(p_height <= 0 || p_height > 16384);
+	//real texture size is in alloc width and height
+	texture->width = p_width;
+	texture->height = p_height;
+}
+
+void TextureStorage::texture_set_path(RID p_texture, const String &p_path) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->path = p_path;
+}
+
+String TextureStorage::texture_get_path(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND_V(!texture, "");
+
+	return texture->path;
+}
+
+void TextureStorage::texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->detect_3d = p_callback;
+	texture->detect_3d_ud = p_userdata;
+}
+
+void TextureStorage::texture_set_detect_srgb_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->detect_srgb = p_callback;
+	texture->detect_srgb_ud = p_userdata;
+}
+
+void TextureStorage::texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->detect_normal = p_callback;
+	texture->detect_normal_ud = p_userdata;
+}
+
+void TextureStorage::texture_debug_usage(List<RS::TextureInfo> *r_info) {
+	List<RID> textures;
+	texture_owner.get_owned_list(&textures);
+
+	for (List<RID>::Element *E = textures.front(); E; E = E->next()) {
+		Texture *t = texture_owner.get_or_null(E->get());
+		if (!t) {
+			continue;
+		}
+		RS::TextureInfo tinfo;
+		tinfo.path = t->path;
+		tinfo.format = t->format;
+		tinfo.width = t->alloc_width;
+		tinfo.height = t->alloc_height;
+		tinfo.depth = 0;
+		tinfo.bytes = t->total_data_size;
+		r_info->push_back(tinfo);
+	}
+}
+
+void TextureStorage::texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	texture->redraw_if_visible = p_enable;
+}
+
+Size2 TextureStorage::texture_size_with_proxy(RID p_texture) {
+	const Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND_V(!texture, Size2());
+	if (texture->proxy) {
+		return Size2(texture->proxy->width, texture->proxy->height);
+	} else {
+		return Size2(texture->width, texture->height);
+	}
+}
+
+// example use in 3.2
+// VS::get_singleton()->texture_set_proxy(default_texture->proxy, texture_rid);
+
+// p_proxy is the source (pre-existing) texture?
+// and p_texture is the one that is being made into a proxy?
+//This naming is confusing. Comments!!!
+
+// The naming of the parameters seemed to be reversed?
+// The p_proxy is the source texture
+// and p_texture is actually the proxy????
+
+void TextureStorage::texture_set_proxy(RID p_texture, RID p_proxy) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	if (texture->proxy) {
+		texture->proxy->proxy_owners.erase(texture);
+		texture->proxy = nullptr;
+	}
+
+	if (p_proxy.is_valid()) {
+		Texture *proxy = texture_owner.get_or_null(p_proxy);
+		ERR_FAIL_COND(!proxy);
+		ERR_FAIL_COND(proxy == texture);
+		proxy->proxy_owners.insert(texture);
+		texture->proxy = proxy;
+	}
+}
+
+void TextureStorage::texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer) {
+	Config *config = Config::get_singleton();
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND(!_is_main_thread());
+
+	ERR_FAIL_COND(!texture);
+	if (texture->target == GL_TEXTURE_3D) {
+		// Target is set to a 3D texture or array texture, exit early to avoid spamming errors
+		return;
+	}
+	ERR_FAIL_COND(!texture->active);
+	ERR_FAIL_COND(texture->render_target);
+	ERR_FAIL_COND(p_image.is_null());
+	ERR_FAIL_COND(texture->format != p_image->get_format());
+
+	ERR_FAIL_COND(!p_image->get_width());
+	ERR_FAIL_COND(!p_image->get_height());
+
+	//	ERR_FAIL_COND(texture->type == RS::TEXTURE_TYPE_EXTERNAL);
+
+	GLenum type;
+	GLenum format;
+	GLenum internal_format;
+	bool compressed = false;
+
+	if (config->keep_original_textures && !(texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING)) {
+		texture->images.write[p_layer] = p_image;
+	}
+
+	// print_line("texture_set_data width " + itos (p_image->get_width()) + " height " + itos(p_image->get_height()));
+
+	Image::Format real_format;
+	Ref<Image> img = _get_gl_image_and_format(p_image, p_image->get_format(), texture->flags, real_format, format, internal_format, type, compressed, texture->resize_to_po2);
+
+	if (texture->resize_to_po2) {
+		if (p_image->is_compressed()) {
+			ERR_PRINT("Texture '" + texture->path + "' is required to be a power of 2 because it uses either mipmaps or repeat, so it was decompressed. This will hurt performance and memory usage.");
+		}
+
+		if (img == p_image) {
+			img = img->duplicate();
+		}
+		img->resize_to_po2(false);
+	}
+
+	if (config->shrink_textures_x2 && (p_image->has_mipmaps() || !p_image->is_compressed()) && !(texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING)) {
+		texture->alloc_height = MAX(1, texture->alloc_height / 2);
+		texture->alloc_width = MAX(1, texture->alloc_width / 2);
+
+		if (texture->alloc_width == img->get_width() / 2 && texture->alloc_height == img->get_height() / 2) {
+			img->shrink_x2();
+		} else if (img->get_format() <= Image::FORMAT_RGBA8) {
+			img->resize(texture->alloc_width, texture->alloc_height, Image::INTERPOLATE_BILINEAR);
+		}
+	}
+
+	GLenum blit_target = (texture->target == GL_TEXTURE_CUBE_MAP) ? _cube_side_enum[p_layer] : GL_TEXTURE_2D;
+
+	texture->data_size = img->get_data().size();
+	Vector<uint8_t> read = img->get_data();
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	texture->ignore_mipmaps = compressed && !img->has_mipmaps();
+
+	// set filtering and repeat state
+	_texture_set_state_from_flags(texture);
+
+	//set swizle for older format compatibility
+#ifdef GLES_OVER_GL
+	switch (texture->format) {
+		case Image::FORMAT_L8: {
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ONE);
+
+		} break;
+		case Image::FORMAT_LA8: {
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_GREEN);
+		} break;
+		default: {
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_R, GL_RED);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_G, GL_GREEN);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_B, GL_BLUE);
+			glTexParameteri(texture->target, GL_TEXTURE_SWIZZLE_A, GL_ALPHA);
+
+		} break;
+	}
+#endif
+
+	int mipmaps = ((texture->flags & TEXTURE_FLAG_MIPMAPS) && img->has_mipmaps()) ? img->get_mipmap_count() + 1 : 1;
+
+	int w = img->get_width();
+	int h = img->get_height();
+
+	int tsize = 0;
+
+	for (int i = 0; i < mipmaps; i++) {
+		int size, ofs;
+		img->get_mipmap_offset_and_size(i, ofs, size);
+
+		if (compressed) {
+			glPixelStorei(GL_UNPACK_ALIGNMENT, 4);
+
+			int bw = w;
+			int bh = h;
+
+			glCompressedTexImage2D(blit_target, i, internal_format, bw, bh, 0, size, &read[ofs]);
+		} else {
+			glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
+			if (texture->flags & TEXTURE_FLAG_USED_FOR_STREAMING) {
+				glTexSubImage2D(blit_target, i, 0, 0, w, h, format, type, &read[ofs]);
+			} else {
+				glTexImage2D(blit_target, i, internal_format, w, h, 0, format, type, &read[ofs]);
+			}
+		}
+
+		tsize += size;
+
+		w = MAX(1, w >> 1);
+		h = MAX(1, h >> 1);
+	}
+
+	// info.texture_mem -= texture->total_data_size; // TODO make this work again!!
+	texture->total_data_size = tsize;
+	// info.texture_mem += texture->total_data_size; // TODO make this work again!!
+
+	// printf("texture: %i x %i - size: %i - total: %i\n", texture->width, texture->height, tsize, info.texture_mem);
+
+	texture->stored_cube_sides |= (1 << p_layer);
+
+	if ((texture->flags & TEXTURE_FLAG_MIPMAPS) && mipmaps == 1 && !texture->ignore_mipmaps && (texture->type != RenderingDevice::TEXTURE_TYPE_CUBE || texture->stored_cube_sides == (1 << 6) - 1)) {
+		//generate mipmaps if they were requested and the image does not contain them
+		glGenerateMipmap(texture->target);
+	}
+
+	texture->mipmaps = mipmaps;
+}
+
+void TextureStorage::texture_set_data_partial(RID p_texture, const Ref<Image> &p_image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int p_dst_mip, int p_layer) {
+	// TODO
+	ERR_PRINT("Not implemented (ask Karroffel to do it :p)");
+}
+
+/*
+Ref<Image> TextureStorage::texture_get_data(RID p_texture, int p_layer) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, Ref<Image>());
+	ERR_FAIL_COND_V(!texture->active, Ref<Image>());
+	ERR_FAIL_COND_V(texture->data_size == 0 && !texture->render_target, Ref<Image>());
+
+	if (texture->type == RS::TEXTURE_TYPE_CUBEMAP && p_layer < 6 && p_layer >= 0 && !texture->images[p_layer].is_null()) {
+		return texture->images[p_layer];
+	}
+
+#ifdef GLES_OVER_GL
+
+	Image::Format real_format;
+	GLenum gl_format;
+	GLenum gl_internal_format;
+	GLenum gl_type;
+	bool compressed;
+	_get_gl_image_and_format(Ref<Image>(), texture->format, texture->flags, real_format, gl_format, gl_internal_format, gl_type, compressed, false);
+
+	PoolVector<uint8_t> data;
+
+	int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, real_format, texture->mipmaps > 1);
+
+	data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
+	PoolVector<uint8_t>::Write wb = data.write();
+
+	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, real_format, i);
+
+		if (texture->compressed) {
+			glPixelStorei(GL_PACK_ALIGNMENT, 4);
+			glGetCompressedTexImage(texture->target, i, &wb[ofs]);
+		} else {
+			glPixelStorei(GL_PACK_ALIGNMENT, 1);
+			glGetTexImage(texture->target, i, texture->gl_format_cache, texture->gl_type_cache, &wb[ofs]);
+		}
+	}
+
+	wb.release();
+
+	data.resize(data_size);
+
+	Image *img = memnew(Image(texture->alloc_width, texture->alloc_height, texture->mipmaps > 1, real_format, data));
+
+	return Ref<Image>(img);
+#else
+
+	Image::Format real_format;
+	GLenum gl_format;
+	GLenum gl_internal_format;
+	GLenum gl_type;
+	bool compressed;
+	_get_gl_image_and_format(Ref<Image>(), texture->format, texture->flags, real_format, gl_format, gl_internal_format, gl_type, compressed, texture->resize_to_po2);
+
+	PoolVector<uint8_t> data;
+
+	int data_size = Image::get_image_data_size(texture->alloc_width, texture->alloc_height, Image::FORMAT_RGBA8, false);
+
+	data.resize(data_size * 2); //add some memory at the end, just in case for buggy drivers
+	PoolVector<uint8_t>::Write wb = data.write();
+
+	GLuint temp_framebuffer;
+	glGenFramebuffers(1, &temp_framebuffer);
+
+	GLuint temp_color_texture;
+	glGenTextures(1, &temp_color_texture);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, temp_framebuffer);
+
+	glBindTexture(GL_TEXTURE_2D, temp_color_texture);
+	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, texture->alloc_width, texture->alloc_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
+
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
+	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
+	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, temp_color_texture, 0);
+
+	glDepthMask(GL_FALSE);
+	glDisable(GL_DEPTH_TEST);
+	glDisable(GL_CULL_FACE);
+	glDisable(GL_BLEND);
+	glDepthFunc(GL_LEQUAL);
+	glColorMask(1, 1, 1, 1);
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(GL_TEXTURE_2D, texture->tex_id);
+
+	glViewport(0, 0, texture->alloc_width, texture->alloc_height);
+
+	shaders.copy.bind();
+
+	glClearColor(0.0, 0.0, 0.0, 0.0);
+	glClear(GL_COLOR_BUFFER_BIT);
+	bind_quad_array();
+	glDrawArrays(GL_TRIANGLE_FAN, 0, 4);
+	glBindBuffer(GL_ARRAY_BUFFER, 0);
+
+	glReadPixels(0, 0, texture->alloc_width, texture->alloc_height, GL_RGBA, GL_UNSIGNED_BYTE, &wb[0]);
+
+	glDeleteTextures(1, &temp_color_texture);
+
+	glBindFramebuffer(GL_FRAMEBUFFER, 0);
+	glDeleteFramebuffers(1, &temp_framebuffer);
+
+	wb.release();
+
+	data.resize(data_size);
+
+	Image *img = memnew(Image(texture->alloc_width, texture->alloc_height, false, Image::FORMAT_RGBA8, data));
+	if (!texture->compressed) {
+		img->convert(real_format);
+	}
+
+	return Ref<Image>(img);
+
+#endif
+}
+*/
+
+void TextureStorage::texture_set_flags(RID p_texture, uint32_t p_flags) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+	ERR_FAIL_COND(!texture);
+
+	bool had_mipmaps = texture->flags & TEXTURE_FLAG_MIPMAPS;
+
+	texture->flags = p_flags;
+
+	glActiveTexture(GL_TEXTURE0);
+	glBindTexture(texture->target, texture->tex_id);
+
+	// set filtering and repeat state
+	_texture_set_state_from_flags(texture);
+
+	if ((texture->flags & TEXTURE_FLAG_MIPMAPS) && !texture->ignore_mipmaps) {
+		if (!had_mipmaps && texture->mipmaps == 1) {
+			glGenerateMipmap(texture->target);
+		}
+	}
+}
+
+uint32_t TextureStorage::texture_get_flags(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, 0);
+
+	return texture->flags;
+}
+
+Image::Format TextureStorage::texture_get_format(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, Image::FORMAT_L8);
+
+	return texture->format;
+}
+
+RenderingDevice::TextureType TextureStorage::texture_get_type(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, RenderingDevice::TEXTURE_TYPE_2D);
+
+	return texture->type;
+}
+
+uint32_t TextureStorage::texture_get_texid(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, 0);
+
+	return texture->tex_id;
+}
+
+uint32_t TextureStorage::texture_get_width(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, 0);
+
+	return texture->width;
+}
+
+uint32_t TextureStorage::texture_get_height(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, 0);
+
+	return texture->height;
+}
+
+uint32_t TextureStorage::texture_get_depth(RID p_texture) const {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND_V(!texture, 0);
+
+	return texture->depth;
+}
+
+void TextureStorage::texture_bind(RID p_texture, uint32_t p_texture_no) {
+	Texture *texture = texture_owner.get_or_null(p_texture);
+
+	ERR_FAIL_COND(!texture);
+
+	glActiveTexture(GL_TEXTURE0 + p_texture_no);
+	glBindTexture(texture->target, texture->tex_id);
+}
+
+void TextureStorage::texture_set_shrink_all_x2_on_set_data(bool p_enable) {
+	Config::get_singleton()->shrink_textures_x2 = p_enable;
+}
+
+RID TextureStorage::texture_create_radiance_cubemap(RID p_source, int p_resolution) const {
+	return RID();
+}
+
+void TextureStorage::textures_keep_original(bool p_enable) {
+	Config::get_singleton()->keep_original_textures = p_enable;
+}
+
+#endif // GLES3_ENABLED
diff --git a/drivers/gles3/storage/texture_storage.h b/drivers/gles3/storage/texture_storage.h
new file mode 100644
index 0000000000..8a921fbe10
--- /dev/null
+++ b/drivers/gles3/storage/texture_storage.h
@@ -0,0 +1,389 @@
+/*************************************************************************/
+/*  texture_storage.h                                                    */
+/*************************************************************************/
+/*                       This file is part of:                           */
+/*                           GODOT ENGINE                                */
+/*                      https://godotengine.org                          */
+/*************************************************************************/
+/* Copyright (c) 2007-2022 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2022 Godot Engine contributors (cf. AUTHORS.md).   */
+/*                                                                       */
+/* Permission is hereby granted, free of charge, to any person obtaining */
+/* a copy of this software and associated documentation files (the       */
+/* "Software"), to deal in the Software without restriction, including   */
+/* without limitation the rights to use, copy, modify, merge, publish,   */
+/* distribute, sublicense, and/or sell copies of the Software, and to    */
+/* permit persons to whom the Software is furnished to do so, subject to */
+/* the following conditions:                                             */
+/*                                                                       */
+/* The above copyright notice and this permission notice shall be        */
+/* included in all copies or substantial portions of the Software.       */
+/*                                                                       */
+/* THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,       */
+/* EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF    */
+/* MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.*/
+/* IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY  */
+/* CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT,  */
+/* TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE     */
+/* SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.                */
+/*************************************************************************/
+
+#ifndef TEXTURE_STORAGE_GLES3_H
+#define TEXTURE_STORAGE_GLES3_H
+
+#ifdef GLES3_ENABLED
+
+#include "canvas_texture_storage.h"
+#include "config.h"
+#include "core/os/os.h"
+#include "core/templates/rid_owner.h"
+#include "render_target_storage.h"
+#include "servers/rendering/storage/texture_storage.h"
+
+namespace GLES3 {
+
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT1_EXT 0x83F1
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT3_EXT 0x83F2
+#define _EXT_COMPRESSED_RGBA_S3TC_DXT5_EXT 0x83F3
+
+#define _EXT_COMPRESSED_RED_RGTC1_EXT 0x8DBB
+#define _EXT_COMPRESSED_RED_RGTC1 0x8DBB
+#define _EXT_COMPRESSED_SIGNED_RED_RGTC1 0x8DBC
+#define _EXT_COMPRESSED_RG_RGTC2 0x8DBD
+#define _EXT_COMPRESSED_SIGNED_RG_RGTC2 0x8DBE
+#define _EXT_COMPRESSED_SIGNED_RED_RGTC1_EXT 0x8DBC
+#define _EXT_COMPRESSED_RED_GREEN_RGTC2_EXT 0x8DBD
+#define _EXT_COMPRESSED_SIGNED_RED_GREEN_RGTC2_EXT 0x8DBE
+#define _EXT_ETC1_RGB8_OES 0x8D64
+
+#define _EXT_COMPRESSED_RGBA_BPTC_UNORM 0x8E8C
+#define _EXT_COMPRESSED_SRGB_ALPHA_BPTC_UNORM 0x8E8D
+#define _EXT_COMPRESSED_RGB_BPTC_SIGNED_FLOAT 0x8E8E
+#define _EXT_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT 0x8E8F
+
+#define _GL_TEXTURE_EXTERNAL_OES 0x8D65
+
+#ifdef GLES_OVER_GL
+#define _GL_HALF_FLOAT_OES 0x140B
+#else
+#define _GL_HALF_FLOAT_OES 0x8D61
+#endif
+
+#define _EXT_TEXTURE_CUBE_MAP_SEAMLESS 0x884F
+
+#define _RED_OES 0x1903
+
+#define _DEPTH_COMPONENT24_OES 0x81A6
+
+#ifndef GLES_OVER_GL
+#define glClearDepth glClearDepthf
+#endif //!GLES_OVER_GL
+
+enum OpenGLTextureFlags {
+	TEXTURE_FLAG_MIPMAPS = 1, /// Enable automatic mipmap generation - when available
+	TEXTURE_FLAG_REPEAT = 2, /// Repeat texture (Tiling), otherwise Clamping
+	TEXTURE_FLAG_FILTER = 4, /// Create texture with linear (or available) filter
+	TEXTURE_FLAG_ANISOTROPIC_FILTER = 8,
+	TEXTURE_FLAG_CONVERT_TO_LINEAR = 16,
+	TEXTURE_FLAG_MIRRORED_REPEAT = 32, /// Repeat texture, with alternate sections mirrored
+	TEXTURE_FLAG_USED_FOR_STREAMING = 2048,
+	TEXTURE_FLAGS_DEFAULT = TEXTURE_FLAG_REPEAT | TEXTURE_FLAG_MIPMAPS | TEXTURE_FLAG_FILTER
+};
+
+struct Texture {
+	RID self;
+
+	Texture *proxy;
+	Set<Texture *> proxy_owners;
+
+	String path;
+	uint32_t flags;
+	int width, height, depth;
+	int alloc_width, alloc_height;
+	Image::Format format;
+	RenderingDevice::TextureType type;
+
+	GLenum target;
+	GLenum gl_format_cache;
+	GLenum gl_internal_format_cache;
+	GLenum gl_type_cache;
+
+	int data_size;
+	int total_data_size;
+	bool ignore_mipmaps;
+
+	bool compressed;
+
+	bool srgb;
+
+	int mipmaps;
+
+	bool resize_to_po2;
+
+	bool active;
+	GLenum tex_id;
+
+	uint16_t stored_cube_sides;
+
+	RenderTarget *render_target;
+
+	Vector<Ref<Image>> images;
+
+	bool redraw_if_visible;
+
+	RS::TextureDetectCallback detect_3d;
+	void *detect_3d_ud;
+
+	RS::TextureDetectCallback detect_srgb;
+	void *detect_srgb_ud;
+
+	RS::TextureDetectCallback detect_normal;
+	void *detect_normal_ud;
+
+	CanvasTexture *canvas_texture = nullptr;
+
+	// some silly opengl shenanigans where
+	// texture coords start from bottom left, means we need to draw render target textures upside down
+	// to be compatible with vulkan etc.
+	bool is_upside_down() const {
+		if (proxy) {
+			return proxy->is_upside_down();
+		}
+
+		return render_target != nullptr;
+	}
+
+	Texture() {
+		create();
+	}
+
+	_ALWAYS_INLINE_ Texture *get_ptr() {
+		if (proxy) {
+			return proxy; //->get_ptr(); only one level of indirection, else not inlining possible.
+		} else {
+			return this;
+		}
+	}
+
+	~Texture() {
+		destroy();
+
+		if (tex_id != 0) {
+			glDeleteTextures(1, &tex_id);
+		}
+	}
+
+	void copy_from(const Texture &o) {
+		proxy = o.proxy;
+		flags = o.flags;
+		width = o.width;
+		height = o.height;
+		alloc_width = o.alloc_width;
+		alloc_height = o.alloc_height;
+		format = o.format;
+		type = o.type;
+		target = o.target;
+		data_size = o.data_size;
+		total_data_size = o.total_data_size;
+		ignore_mipmaps = o.ignore_mipmaps;
+		compressed = o.compressed;
+		mipmaps = o.mipmaps;
+		resize_to_po2 = o.resize_to_po2;
+		active = o.active;
+		tex_id = o.tex_id;
+		stored_cube_sides = o.stored_cube_sides;
+		render_target = o.render_target;
+		redraw_if_visible = o.redraw_if_visible;
+		detect_3d = o.detect_3d;
+		detect_3d_ud = o.detect_3d_ud;
+		detect_srgb = o.detect_srgb;
+		detect_srgb_ud = o.detect_srgb_ud;
+		detect_normal = o.detect_normal;
+		detect_normal_ud = o.detect_normal_ud;
+
+		images.clear();
+	}
+
+	void create() {
+		proxy = nullptr;
+		flags = 0;
+		width = 0;
+		height = 0;
+		alloc_width = 0;
+		alloc_height = 0;
+		format = Image::FORMAT_L8;
+		type = RenderingDevice::TEXTURE_TYPE_2D;
+		target = 0;
+		data_size = 0;
+		total_data_size = 0;
+		ignore_mipmaps = false;
+		compressed = false;
+		mipmaps = 0;
+		resize_to_po2 = false;
+		active = false;
+		tex_id = 0;
+		stored_cube_sides = 0;
+		render_target = nullptr;
+		redraw_if_visible = false;
+		detect_3d = nullptr;
+		detect_3d_ud = nullptr;
+		detect_srgb = nullptr;
+		detect_srgb_ud = nullptr;
+		detect_normal = nullptr;
+		detect_normal_ud = nullptr;
+	}
+	void destroy() {
+		images.clear();
+
+		for (Set<Texture *>::Element *E = proxy_owners.front(); E; E = E->next()) {
+			E->get()->proxy = nullptr;
+		}
+
+		if (proxy) {
+			proxy->proxy_owners.erase(this);
+		}
+	}
+
+	// texture state
+	void GLSetFilter(GLenum p_target, RS::CanvasItemTextureFilter p_filter) {
+		if (p_filter == state_filter) {
+			return;
+		}
+		state_filter = p_filter;
+		GLint pmin = GL_LINEAR; // param min
+		GLint pmag = GL_LINEAR; // param mag
+		switch (state_filter) {
+			default: {
+			} break;
+			case RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR_WITH_MIPMAPS: {
+				pmin = GL_LINEAR_MIPMAP_LINEAR;
+				pmag = GL_LINEAR;
+			} break;
+			case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST: {
+				pmin = GL_NEAREST;
+				pmag = GL_NEAREST;
+			} break;
+			case RS::CANVAS_ITEM_TEXTURE_FILTER_NEAREST_WITH_MIPMAPS: {
+				pmin = GL_NEAREST_MIPMAP_NEAREST;
+				pmag = GL_NEAREST;
+			} break;
+		}
+		glTexParameteri(p_target, GL_TEXTURE_MIN_FILTER, pmin);
+		glTexParameteri(p_target, GL_TEXTURE_MAG_FILTER, pmag);
+	}
+	void GLSetRepeat(GLenum p_target, RS::CanvasItemTextureRepeat p_repeat) {
+		if (p_repeat == state_repeat) {
+			return;
+		}
+		state_repeat = p_repeat;
+		GLint prep = GL_CLAMP_TO_EDGE; // parameter repeat
+		switch (state_repeat) {
+			default: {
+			} break;
+			case RS::CANVAS_ITEM_TEXTURE_REPEAT_ENABLED: {
+				prep = GL_REPEAT;
+			} break;
+			case RS::CANVAS_ITEM_TEXTURE_REPEAT_MIRROR: {
+				prep = GL_MIRRORED_REPEAT;
+			} break;
+		}
+		glTexParameteri(p_target, GL_TEXTURE_WRAP_S, prep);
+		glTexParameteri(p_target, GL_TEXTURE_WRAP_T, prep);
+	}
+
+private:
+	RS::CanvasItemTextureFilter state_filter = RS::CANVAS_ITEM_TEXTURE_FILTER_LINEAR;
+	RS::CanvasItemTextureRepeat state_repeat = RS::CANVAS_ITEM_TEXTURE_REPEAT_DISABLED;
+};
+
+class TextureStorage : public RendererTextureStorage {
+private:
+	static TextureStorage *singleton;
+
+	Thread::ID _main_thread_id = 0;
+	bool _is_main_thread();
+
+	mutable RID_PtrOwner<Texture> texture_owner;
+
+	Ref<Image> _get_gl_image_and_format(const Ref<Image> &p_image, Image::Format p_format, uint32_t p_flags, Image::Format &r_real_format, GLenum &r_gl_format, GLenum &r_gl_internal_format, GLenum &r_gl_type, bool &r_compressed, bool p_force_decompress) const;
+	void _texture_set_state_from_flags(Texture *p_tex);
+
+	void texture_set_proxy(RID p_texture, RID p_proxy);
+
+public:
+	static TextureStorage *get_singleton();
+
+	TextureStorage();
+	virtual ~TextureStorage();
+
+	Texture *get_texture(RID p_rid) { return texture_owner.get_or_null(p_rid); };
+	bool owns_texture(RID p_rid) { return texture_owner.owns(p_rid); };
+	RID make_rid(Texture *p_texture) { return texture_owner.make_rid(p_texture); };
+
+	void set_main_thread_id(Thread::ID p_id);
+
+	virtual bool can_create_resources_async() const override;
+
+	RID texture_create();
+	void _texture_allocate_internal(RID p_texture, int p_width, int p_height, int p_depth_3d, Image::Format p_format, RenderingDevice::TextureType p_type, uint32_t p_flags = TEXTURE_FLAGS_DEFAULT);
+
+	virtual RID texture_allocate() override;
+	virtual void texture_free(RID p_rid) override;
+
+	virtual void texture_2d_initialize(RID p_texture, const Ref<Image> &p_image) override;
+	virtual void texture_2d_layered_initialize(RID p_texture, const Vector<Ref<Image>> &p_layers, RS::TextureLayeredType p_layered_type) override;
+	virtual void texture_3d_initialize(RID p_texture, Image::Format, int p_width, int p_height, int p_depth, bool p_mipmaps, const Vector<Ref<Image>> &p_data) override;
+	virtual void texture_proxy_initialize(RID p_texture, RID p_base) override; //all slices, then all the mipmaps, must be coherent
+
+	virtual void texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer = 0) override;
+	virtual void texture_3d_update(RID p_texture, const Vector<Ref<Image>> &p_data) override{};
+	virtual void texture_proxy_update(RID p_proxy, RID p_base) override{};
+
+	//these two APIs can be used together or in combination with the others.
+	virtual void texture_2d_placeholder_initialize(RID p_texture) override;
+	virtual void texture_2d_layered_placeholder_initialize(RID p_texture, RenderingServer::TextureLayeredType p_layered_type) override;
+	virtual void texture_3d_placeholder_initialize(RID p_texture) override;
+
+	virtual Ref<Image> texture_2d_get(RID p_texture) const override;
+	virtual Ref<Image> texture_2d_layer_get(RID p_texture, int p_layer) const override { return Ref<Image>(); };
+	virtual Vector<Ref<Image>> texture_3d_get(RID p_texture) const override { return Vector<Ref<Image>>(); };
+
+	virtual void texture_replace(RID p_texture, RID p_by_texture) override;
+	virtual void texture_set_size_override(RID p_texture, int p_width, int p_height) override;
+
+	virtual void texture_set_path(RID p_texture, const String &p_path) override;
+	virtual String texture_get_path(RID p_texture) const override;
+
+	virtual void texture_set_detect_3d_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
+	void texture_set_detect_srgb_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata);
+	virtual void texture_set_detect_normal_callback(RID p_texture, RS::TextureDetectCallback p_callback, void *p_userdata) override;
+	virtual void texture_set_detect_roughness_callback(RID p_texture, RS::TextureDetectRoughnessCallback p_callback, void *p_userdata) override{};
+
+	virtual void texture_debug_usage(List<RS::TextureInfo> *r_info) override;
+
+	virtual void texture_set_force_redraw_if_visible(RID p_texture, bool p_enable) override;
+
+	virtual Size2 texture_size_with_proxy(RID p_proxy) override;
+
+	void texture_set_data(RID p_texture, const Ref<Image> &p_image, int p_layer = 0);
+	void texture_set_data_partial(RID p_texture, const Ref<Image> &p_image, int src_x, int src_y, int src_w, int src_h, int dst_x, int dst_y, int p_dst_mip, int p_layer = 0);
+	//Ref<Image> texture_get_data(RID p_texture, int p_layer = 0) const;
+	void texture_set_flags(RID p_texture, uint32_t p_flags);
+	uint32_t texture_get_flags(RID p_texture) const;
+	Image::Format texture_get_format(RID p_texture) const;
+	RenderingDevice::TextureType texture_get_type(RID p_texture) const;
+	uint32_t texture_get_texid(RID p_texture) const;
+	uint32_t texture_get_width(RID p_texture) const;
+	uint32_t texture_get_height(RID p_texture) const;
+	uint32_t texture_get_depth(RID p_texture) const;
+	void texture_bind(RID p_texture, uint32_t p_texture_no);
+	void texture_set_shrink_all_x2_on_set_data(bool p_enable);
+	RID texture_create_radiance_cubemap(RID p_source, int p_resolution = -1) const;
+	void textures_keep_original(bool p_enable);
+};
+
+} // namespace GLES3
+
+#endif // !GLES3_ENABLED
+
+#endif // !TEXTURE_STORAGE_GLES3_H