Add support for OpenGL to OpenXR

4 files changed, 264 insertions, 122 deletions

diff --git a/drivers/gles3/storage/render_scene_buffers_gles3.cpp b/drivers/gles3/storage/render_scene_buffers_gles3.cpp
index b8e4530f56..e0e78de728 100644
--- a/drivers/gles3/storage/render_scene_buffers_gles3.cpp
+++ b/drivers/gles3/storage/render_scene_buffers_gles3.cpp
@@ -33,17 +33,12 @@
 #include "render_scene_buffers_gles3.h"
 #include "texture_storage.h"
 
-#ifdef ANDROID_ENABLED
-#define glFramebufferTextureMultiviewOVR GLES3::Config::get_singleton()->eglFramebufferTextureMultiviewOVR
-#endif
-
 RenderSceneBuffersGLES3::~RenderSceneBuffersGLES3() {
 	free_render_buffer_data();
 }
 
 void RenderSceneBuffersGLES3::configure(RID p_render_target, const Size2i p_internal_size, const Size2i p_target_size, float p_fsr_sharpness, float p_texture_mipmap_bias, RS::ViewportMSAA p_msaa, RenderingServer::ViewportScreenSpaceAA p_screen_space_aa, bool p_use_taa, bool p_use_debanding, uint32_t p_view_count) {
 	GLES3::TextureStorage *texture_storage = GLES3::TextureStorage::get_singleton();
-	GLES3::Config *config = GLES3::Config::get_singleton();
 
 	//internal_size.x = p_internal_size.x; // ignore for now
 	//internal_size.y = p_internal_size.y;
@@ -62,66 +57,9 @@ void RenderSceneBuffersGLES3::configure(RID p_render_target, const Size2i p_inte
 	GLES3::RenderTarget *rt = texture_storage->get_render_target(p_render_target);
 
 	is_transparent = rt->is_transparent;
-
-	// framebuffer
-	glGenFramebuffers(1, &framebuffer);
-	glBindFramebuffer(GL_FRAMEBUFFER, framebuffer);
-
-	if (view_count > 1 && config->multiview_supported) {
-		glBindTexture(GL_TEXTURE_2D_ARRAY, rt->color);
-		glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, rt->color, 0, 0, view_count);
-	} else {
-		glBindTexture(GL_TEXTURE_2D, rt->color);
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->color, 0);
-	}
-
-	glGenTextures(1, &depth_texture);
-	if (view_count > 1 && config->multiview_supported) {
-		glBindTexture(GL_TEXTURE_2D_ARRAY, depth_texture);
-		glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, GL_DEPTH_COMPONENT24, rt->size.x, rt->size.y, view_count, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
-
-		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-		glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	} else {
-		glBindTexture(GL_TEXTURE_2D, depth_texture);
-		glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT24, rt->size.x, rt->size.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
-
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-		glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-	}
-
-	if (view_count > 1 && config->multiview_supported) {
-		glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, depth_texture, 0, 0, view_count);
-	} else {
-		glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, depth_texture, 0);
-	}
-
-	GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
-
-	glBindTexture(GL_TEXTURE_2D, 0);
-	glBindTexture(GL_TEXTURE_2D_ARRAY, 0);
-	glBindFramebuffer(GL_FRAMEBUFFER, texture_storage->system_fbo);
-
-	if (status != GL_FRAMEBUFFER_COMPLETE) {
-		free_render_buffer_data();
-		WARN_PRINT("Could not create 3D renderbuffer, status: " + texture_storage->get_framebuffer_error(status));
-		return;
-	}
 }
 
 void RenderSceneBuffersGLES3::free_render_buffer_data() {
-	if (depth_texture) {
-		glDeleteTextures(1, &depth_texture);
-		depth_texture = 0;
-	}
-	if (framebuffer) {
-		glDeleteFramebuffers(1, &framebuffer);
-		framebuffer = 0;
-	}
 }
 
 #endif // GLES3_ENABLED
diff --git a/drivers/gles3/storage/render_scene_buffers_gles3.h b/drivers/gles3/storage/render_scene_buffers_gles3.h
index dbedbd22c3..092c14e1b8 100644
--- a/drivers/gles3/storage/render_scene_buffers_gles3.h
+++ b/drivers/gles3/storage/render_scene_buffers_gles3.h
@@ -61,9 +61,6 @@ public:
 	bool is_transparent = false;
 
 	RID render_target;
-	GLuint internal_texture = 0; // Used for rendering when post effects are enabled
-	GLuint depth_texture = 0; // Main depth texture
-	GLuint framebuffer = 0; // Main framebuffer, contains internal_texture and depth_texture or render_target->color and depth_texture
 
 	//built-in textures used for ping pong image processing and blurring
 	struct Blur {
diff --git a/drivers/gles3/storage/texture_storage.cpp b/drivers/gles3/storage/texture_storage.cpp
index 11151c4100..e0457a8d28 100644
--- a/drivers/gles3/storage/texture_storage.cpp
+++ b/drivers/gles3/storage/texture_storage.cpp
@@ -614,7 +614,9 @@ void TextureStorage::texture_free(RID p_texture) {
 	}
 
 	if (t->tex_id != 0) {
-		glDeleteTextures(1, &t->tex_id);
+		if (!t->is_external) {
+			glDeleteTextures(1, &t->tex_id);
+		}
 		t->tex_id = 0;
 	}
 
@@ -680,6 +682,35 @@ void TextureStorage::texture_proxy_initialize(RID p_texture, RID p_base) {
 	texture_owner.initialize_rid(p_texture, proxy_tex);
 }
 
+RID TextureStorage::texture_create_external(Texture::Type p_type, Image::Format p_format, unsigned int p_image, int p_width, int p_height, int p_depth, int p_layers, RS::TextureLayeredType p_layered_type) {
+	Texture texture;
+	texture.active = true;
+	texture.is_external = true;
+	texture.type = p_type;
+
+	switch (p_type) {
+		case Texture::TYPE_2D: {
+			texture.target = GL_TEXTURE_2D;
+		} break;
+		case Texture::TYPE_3D: {
+			texture.target = GL_TEXTURE_3D;
+		} break;
+		case Texture::TYPE_LAYERED: {
+			texture.target = GL_TEXTURE_2D_ARRAY;
+		} break;
+	}
+
+	texture.real_format = texture.format = p_format;
+	texture.tex_id = p_image;
+	texture.alloc_width = texture.width = p_width;
+	texture.alloc_height = texture.height = p_height;
+	texture.depth = p_depth;
+	texture.layers = p_layers;
+	texture.layered_type = p_layered_type;
+
+	return texture_owner.make_rid(texture);
+}
+
 void TextureStorage::texture_2d_update(RID p_texture, const Ref<Image> &p_image, int p_layer) {
 	texture_set_data(p_texture, p_image, p_layer);
 #ifdef TOOLS_ENABLED
@@ -1459,43 +1490,74 @@ void TextureStorage::_update_render_target(RenderTarget *rt) {
 	glDepthMask(GL_FALSE);
 
 	{
-		/* Front FBO */
+		Texture *texture;
+		bool use_multiview = rt->view_count > 1 && config->multiview_supported;
+		GLenum texture_target = use_multiview ? GL_TEXTURE_2D_ARRAY : GL_TEXTURE_2D;
 
-		Texture *texture = get_texture(rt->texture);
-		ERR_FAIL_COND(!texture);
+		/* Front FBO */
 
-		// framebuffer
 		glGenFramebuffers(1, &rt->fbo);
 		glBindFramebuffer(GL_FRAMEBUFFER, rt->fbo);
 
 		// color
-		glGenTextures(1, &rt->color);
-		if (rt->view_count > 1 && config->multiview_supported) {
-			glBindTexture(GL_TEXTURE_2D_ARRAY, rt->color);
-			glTexImage3D(GL_TEXTURE_2D_ARRAY, 0, rt->color_internal_format, rt->size.x, rt->size.y, rt->view_count, 0, rt->color_format, rt->color_type, nullptr);
-
-			glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D_ARRAY, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		if (rt->overridden.color.is_valid()) {
+			texture = get_texture(rt->overridden.color);
+			ERR_FAIL_COND(!texture);
+
+			rt->color = texture->tex_id;
+			rt->size = Size2i(texture->width, texture->height);
 		} else {
-			glBindTexture(GL_TEXTURE_2D, rt->color);
-			glTexImage2D(GL_TEXTURE_2D, 0, rt->color_internal_format, rt->size.x, rt->size.y, 0, rt->color_format, rt->color_type, nullptr);
+			texture = get_texture(rt->texture);
+			ERR_FAIL_COND(!texture);
 
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
-			glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
-		}
+			glGenTextures(1, &rt->color);
+			glBindTexture(texture_target, rt->color);
+
+			if (use_multiview) {
+				glTexImage3D(texture_target, 0, rt->color_internal_format, rt->size.x, rt->size.y, rt->view_count, 0, rt->color_format, rt->color_type, nullptr);
+			} else {
+				glTexImage2D(texture_target, 0, rt->color_internal_format, rt->size.x, rt->size.y, 0, rt->color_format, rt->color_type, nullptr);
+			}
 
-		if (rt->view_count > 1 && config->multiview_supported) {
+			glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		}
+		if (use_multiview) {
 			glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, rt->color, 0, 0, rt->view_count);
 		} else {
 			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, rt->color, 0);
 		}
 
-		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
+		// depth
+		if (rt->overridden.depth.is_valid()) {
+			texture = get_texture(rt->overridden.depth);
+			ERR_FAIL_COND(!texture);
 
+			rt->depth = texture->tex_id;
+		} else {
+			glGenTextures(1, &rt->depth);
+			glBindTexture(texture_target, rt->depth);
+
+			if (use_multiview) {
+				glTexImage3D(texture_target, 0, GL_DEPTH_COMPONENT24, rt->size.x, rt->size.y, rt->view_count, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
+			} else {
+				glTexImage2D(texture_target, 0, GL_DEPTH_COMPONENT24, rt->size.x, rt->size.y, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_INT, nullptr);
+			}
+
+			glTexParameteri(texture_target, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
+			glTexParameteri(texture_target, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
+			glTexParameteri(texture_target, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
+			glTexParameteri(texture_target, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
+		}
+		if (use_multiview) {
+			glFramebufferTextureMultiviewOVR(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, rt->depth, 0, 0, rt->view_count);
+		} else {
+			glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, rt->depth, 0);
+		}
+
+		GLenum status = glCheckFramebufferStatus(GL_FRAMEBUFFER);
 		if (status != GL_FRAMEBUFFER_COMPLETE) {
 			glDeleteFramebuffers(1, &rt->fbo);
 			glDeleteTextures(1, &rt->color);
@@ -1503,32 +1565,38 @@ void TextureStorage::_update_render_target(RenderTarget *rt) {
 			rt->size.x = 0;
 			rt->size.y = 0;
 			rt->color = 0;
-			texture->tex_id = 0;
-			texture->active = false;
+			rt->depth = 0;
+			if (rt->overridden.color.is_null()) {
+				texture->tex_id = 0;
+				texture->active = false;
+			}
 			WARN_PRINT("Could not create render target, status: " + get_framebuffer_error(status));
 			return;
 		}
 
-		texture->format = rt->image_format;
-		texture->real_format = rt->image_format;
-		if (rt->view_count > 1 && config->multiview_supported) {
-			texture->type = Texture::TYPE_LAYERED;
-			texture->target = GL_TEXTURE_2D_ARRAY;
-			texture->layers = rt->view_count;
+		if (rt->overridden.color.is_valid()) {
+			texture->is_render_target = true;
 		} else {
-			texture->type = Texture::TYPE_2D;
-			texture->target = GL_TEXTURE_2D;
-			texture->layers = 1;
+			texture->format = rt->image_format;
+			texture->real_format = rt->image_format;
+			texture->target = texture_target;
+			if (rt->view_count > 1 && config->multiview_supported) {
+				texture->type = Texture::TYPE_LAYERED;
+				texture->layers = rt->view_count;
+			} else {
+				texture->type = Texture::TYPE_2D;
+				texture->layers = 1;
+			}
+			texture->gl_format_cache = rt->color_format;
+			texture->gl_type_cache = GL_UNSIGNED_BYTE;
+			texture->gl_internal_format_cache = rt->color_internal_format;
+			texture->tex_id = rt->color;
+			texture->width = rt->size.x;
+			texture->alloc_width = rt->size.x;
+			texture->height = rt->size.y;
+			texture->alloc_height = rt->size.y;
+			texture->active = true;
 		}
-		texture->gl_format_cache = rt->color_format;
-		texture->gl_type_cache = GL_UNSIGNED_BYTE;
-		texture->gl_internal_format_cache = rt->color_internal_format;
-		texture->tex_id = rt->color;
-		texture->width = rt->size.x;
-		texture->alloc_width = rt->size.x;
-		texture->height = rt->size.y;
-		texture->alloc_height = rt->size.y;
-		texture->active = true;
 	}
 
 	glClearColor(0, 0, 0, 0);
@@ -1596,17 +1664,32 @@ void TextureStorage::_clear_render_target(RenderTarget *rt) {
 
 	if (rt->fbo) {
 		glDeleteFramebuffers(1, &rt->fbo);
-		glDeleteTextures(1, &rt->color);
 		rt->fbo = 0;
+	}
+
+	if (rt->overridden.color.is_null()) {
+		glDeleteTextures(1, &rt->color);
 		rt->color = 0;
 	}
 
-	Texture *tex = get_texture(rt->texture);
-	tex->alloc_height = 0;
-	tex->alloc_width = 0;
-	tex->width = 0;
-	tex->height = 0;
-	tex->active = false;
+	if (rt->overridden.depth.is_null()) {
+		glDeleteTextures(1, &rt->depth);
+		rt->depth = 0;
+	}
+
+	if (rt->texture.is_valid()) {
+		Texture *tex = get_texture(rt->texture);
+		tex->alloc_height = 0;
+		tex->alloc_width = 0;
+		tex->width = 0;
+		tex->height = 0;
+		tex->active = false;
+	}
+
+	if (rt->overridden.color.is_valid()) {
+		Texture *tex = get_texture(rt->overridden.color);
+		tex->is_render_target = false;
+	}
 
 	if (rt->backbuffer_fbo != 0) {
 		glDeleteFramebuffers(1, &rt->backbuffer_fbo);
@@ -1617,6 +1700,15 @@ void TextureStorage::_clear_render_target(RenderTarget *rt) {
 	_render_target_clear_sdf(rt);
 }
 
+void TextureStorage::_clear_render_target_overridden_fbo_cache(RenderTarget *rt) {
+	// Dispose of the cached fbo's and the allocated textures
+	for (KeyValue<uint32_t, RenderTarget::RTOverridden::FBOCacheEntry> &E : rt->overridden.fbo_cache) {
+		glDeleteTextures(E.value.allocated_textures.size(), E.value.allocated_textures.ptr());
+		glDeleteFramebuffers(1, &E.value.fbo);
+	}
+	rt->overridden.fbo_cache.clear();
+}
+
 RID TextureStorage::render_target_create() {
 	RenderTarget render_target;
 	//render_target.was_used = false;
@@ -1635,11 +1727,14 @@ RID TextureStorage::render_target_create() {
 void TextureStorage::render_target_free(RID p_rid) {
 	RenderTarget *rt = render_target_owner.get_or_null(p_rid);
 	_clear_render_target(rt);
+	_clear_render_target_overridden_fbo_cache(rt);
 
 	Texture *t = get_texture(rt->texture);
 	if (t) {
 		t->is_render_target = false;
-		texture_free(rt->texture);
+		if (rt->overridden.color.is_null()) {
+			texture_free(rt->texture);
+		}
 		//memdelete(t);
 	}
 	render_target_owner.free(p_rid);
@@ -1666,6 +1761,9 @@ void TextureStorage::render_target_set_size(RID p_render_target, int p_width, in
 	if (p_width == rt->size.x && p_height == rt->size.y && p_view_count == rt->view_count) {
 		return;
 	}
+	if (rt->overridden.color.is_valid()) {
+		return;
+	}
 
 	_clear_render_target(rt);
 
@@ -1683,10 +1781,91 @@ Size2i TextureStorage::render_target_get_size(RID p_render_target) const {
 	return rt->size;
 }
 
+void TextureStorage::render_target_set_override(RID p_render_target, RID p_color_texture, RID p_depth_texture, RID p_velocity_texture) {
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	ERR_FAIL_COND(!rt);
+	ERR_FAIL_COND(rt->direct_to_screen);
+
+	rt->overridden.velocity = p_velocity_texture;
+
+	if (rt->overridden.color == p_color_texture && rt->overridden.depth == p_depth_texture) {
+		return;
+	}
+
+	if (p_color_texture.is_null() && p_depth_texture.is_null()) {
+		_clear_render_target(rt);
+		rt->overridden.is_overridden = false;
+		rt->overridden.color = RID();
+		rt->overridden.depth = RID();
+		rt->size = Size2i();
+		_clear_render_target_overridden_fbo_cache(rt);
+		return;
+	}
+
+	if (!rt->overridden.is_overridden) {
+		_clear_render_target(rt);
+	}
+
+	rt->overridden.color = p_color_texture;
+	rt->overridden.depth = p_depth_texture;
+	rt->overridden.is_overridden = true;
+
+	uint32_t hash_key = hash_murmur3_one_64(p_color_texture.get_id());
+	hash_key = hash_murmur3_one_64(p_depth_texture.get_id(), hash_key);
+	hash_key = hash_fmix32(hash_key);
+
+	RBMap<uint32_t, RenderTarget::RTOverridden::FBOCacheEntry>::Element *cache;
+	if ((cache = rt->overridden.fbo_cache.find(hash_key)) != nullptr) {
+		rt->fbo = cache->get().fbo;
+		rt->size = cache->get().size;
+		rt->texture = p_color_texture;
+		return;
+	}
+
+	_update_render_target(rt);
+
+	RenderTarget::RTOverridden::FBOCacheEntry new_entry;
+	new_entry.fbo = rt->fbo;
+	new_entry.size = rt->size;
+	// Keep track of any textures we had to allocate because they weren't overridden.
+	if (p_color_texture.is_null()) {
+		new_entry.allocated_textures.push_back(rt->color);
+	}
+	if (p_depth_texture.is_null()) {
+		new_entry.allocated_textures.push_back(rt->depth);
+	}
+	rt->overridden.fbo_cache.insert(hash_key, new_entry);
+}
+
+RID TextureStorage::render_target_get_override_color(RID p_render_target) const {
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	ERR_FAIL_COND_V(!rt, RID());
+
+	return rt->overridden.color;
+}
+
+RID TextureStorage::render_target_get_override_depth(RID p_render_target) const {
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	ERR_FAIL_COND_V(!rt, RID());
+
+	return rt->overridden.depth;
+}
+
+RID TextureStorage::render_target_get_override_velocity(RID p_render_target) const {
+	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
+	ERR_FAIL_COND_V(!rt, RID());
+
+	return rt->overridden.velocity;
+}
+
 RID TextureStorage::render_target_get_texture(RID p_render_target) {
 	RenderTarget *rt = render_target_owner.get_or_null(p_render_target);
 	ERR_FAIL_COND_V(!rt, RID());
 
+	if (rt->overridden.color.is_valid()) {
+		return rt->overridden.color;
+	}
+
 	return rt->texture;
 }
 
@@ -1696,8 +1875,10 @@ void TextureStorage::render_target_set_transparent(RID p_render_target, bool p_t
 
 	rt->is_transparent = p_transparent;
 
-	_clear_render_target(rt);
-	_update_render_target(rt);
+	if (rt->overridden.color.is_null()) {
+		_clear_render_target(rt);
+		_update_render_target(rt);
+	}
 }
 
 bool TextureStorage::render_target_get_transparent(RID p_render_target) const {
@@ -1718,6 +1899,11 @@ void TextureStorage::render_target_set_direct_to_screen(RID p_render_target, boo
 	// those functions change how they operate depending on the value of DIRECT_TO_SCREEN
 	_clear_render_target(rt);
 	rt->direct_to_screen = p_direct_to_screen;
+	if (rt->direct_to_screen) {
+		rt->overridden.color = RID();
+		rt->overridden.depth = RID();
+		rt->overridden.velocity = RID();
+	}
 	_update_render_target(rt);
 }
 
@@ -1750,6 +1936,7 @@ void TextureStorage::render_target_set_msaa(RID p_render_target, RS::ViewportMSA
 	}
 
 	WARN_PRINT("2D MSAA is not yet supported for GLES3.");
+
 	_clear_render_target(rt);
 	rt->msaa = p_msaa;
 	_update_render_target(rt);
diff --git a/drivers/gles3/storage/texture_storage.h b/drivers/gles3/storage/texture_storage.h
index 35fa16c894..5dff768bd7 100644
--- a/drivers/gles3/storage/texture_storage.h
+++ b/drivers/gles3/storage/texture_storage.h
@@ -126,6 +126,7 @@ struct Texture {
 	RID self;
 
 	bool is_proxy = false;
+	bool is_external = false;
 	bool is_render_target = false;
 
 	RID proxy_to = RID();
@@ -187,6 +188,7 @@ struct Texture {
 	void copy_from(const Texture &o) {
 		proxy_to = o.proxy_to;
 		is_proxy = o.is_proxy;
+		is_external = o.is_external;
 		width = o.width;
 		height = o.height;
 		alloc_width = o.alloc_width;
@@ -310,6 +312,7 @@ struct RenderTarget {
 	RID self;
 	GLuint fbo = 0;
 	GLuint color = 0;
+	GLuint depth = 0;
 	GLuint backbuffer_fbo = 0;
 	GLuint backbuffer = 0;
 
@@ -333,6 +336,20 @@ struct RenderTarget {
 	bool used_in_frame = false;
 	RS::ViewportMSAA msaa = RS::VIEWPORT_MSAA_DISABLED;
 
+	struct RTOverridden {
+		bool is_overridden = false;
+		RID color;
+		RID depth;
+		RID velocity;
+
+		struct FBOCacheEntry {
+			GLuint fbo;
+			Size2i size;
+			Vector<GLuint> allocated_textures;
+		};
+		RBMap<uint32_t, FBOCacheEntry> fbo_cache;
+	} overridden;
+
 	RID texture;
 
 	Color clear_color = Color(1, 1, 1, 1);
@@ -395,6 +412,7 @@ private:
 	mutable RID_Owner<RenderTarget> render_target_owner;
 
 	void _clear_render_target(RenderTarget *rt);
+	void _clear_render_target_overridden_fbo_cache(RenderTarget *rt);
 	void _update_render_target(RenderTarget *rt);
 	void _create_render_target_backbuffer(RenderTarget *rt);
 	void _render_target_allocate_sdf(RenderTarget *rt);
@@ -454,6 +472,8 @@ public:
 	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
 
+	RID texture_create_external(Texture::Type p_type, Image::Format p_format, unsigned int p_image, int p_width, int p_height, int p_depth, int p_layers, RS::TextureLayeredType p_layered_type = RS::TEXTURE_LAYERED_2D_ARRAY);
+
 	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;
@@ -593,10 +613,10 @@ public:
 	virtual void render_target_set_vrs_texture(RID p_render_target, RID p_texture) override {}
 	virtual RID render_target_get_vrs_texture(RID p_render_target) const override { return RID(); }
 
-	virtual void render_target_set_override(RID p_render_target, RID p_color_texture, RID p_depth_texture, RID p_velocity_texture) override {}
-	virtual RID render_target_get_override_color(RID p_render_target) const override { return RID(); }
-	virtual RID render_target_get_override_depth(RID p_render_target) const override { return RID(); }
-	virtual RID render_target_get_override_velocity(RID p_render_target) const override { return RID(); }
+	virtual void render_target_set_override(RID p_render_target, RID p_color_texture, RID p_depth_texture, RID p_velocity_texture) override;
+	virtual RID render_target_get_override_color(RID p_render_target) const override;
+	virtual RID render_target_get_override_depth(RID p_render_target) const override;
+	virtual RID render_target_get_override_velocity(RID p_render_target) const override;
 
 	virtual RID render_target_get_texture(RID p_render_target) override;