Merge pull request #59062 from BastiaanOlij/storagerd_texture

8 files changed, 2189 insertions, 0 deletions

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