1 files changed, 119 insertions, 28 deletions

diff --git a/servers/rendering/renderer_viewport.cpp b/servers/rendering/renderer_viewport.cpp
index b67b1cd806..17a665922f 100644
--- a/servers/rendering/renderer_viewport.cpp
+++ b/servers/rendering/renderer_viewport.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2021 Godot Engine contributors (cf. AUTHORS.md).   */
+/* 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       */
@@ -77,18 +77,69 @@ void RendererViewport::_configure_3d_render_buffers(Viewport *p_viewport) {
 			RSG::scene->free(p_viewport->render_buffers);
 			p_viewport->render_buffers = RID();
 		} else {
-			float scale_3d = p_viewport->scale_3d;
-			if (Engine::get_singleton()->is_editor_hint()) {
-				// Ignore the 3D viewport render scaling inside of the editor.
-				// The Half Resolution 3D editor viewport option should be used instead.
-				scale_3d = 1.0;
+			float scaling_3d_scale = p_viewport->scaling_3d_scale;
+
+			RS::ViewportScaling3DMode scaling_3d_mode = p_viewport->scaling_3d_mode;
+			bool scaling_enabled = true;
+
+			if ((scaling_3d_mode == RS::VIEWPORT_SCALING_3D_MODE_FSR) && (scaling_3d_scale > 1.0)) {
+				// FSR is not design for downsampling.
+				// Throw a warning and fallback to VIEWPORT_SCALING_3D_MODE_BILINEAR
+				WARN_PRINT_ONCE("FSR 3D resolution scaling does not support supersampling. Falling back to bilinear scaling.");
+				scaling_3d_mode = RS::VIEWPORT_SCALING_3D_MODE_BILINEAR;
+			}
+
+			if ((scaling_3d_mode == RS::VIEWPORT_SCALING_3D_MODE_FSR) && !p_viewport->fsr_enabled) {
+				// FSR is not actually available.
+				// Throw a warning and fallback to disable scaling
+				WARN_PRINT_ONCE("FSR 3D resolution scaling is not available. Disabling 3D resolution scaling.");
+				scaling_enabled = false;
+			}
+
+			if (scaling_3d_scale == 1.0) {
+				scaling_enabled = false;
+			}
+
+			int width;
+			int height;
+			int render_width;
+			int render_height;
+
+			if (scaling_enabled) {
+				switch (scaling_3d_mode) {
+					case RS::VIEWPORT_SCALING_3D_MODE_BILINEAR:
+						// Clamp 3D rendering resolution to reasonable values supported on most hardware.
+						// This prevents freezing the engine or outright crashing on lower-end GPUs.
+						width = CLAMP(p_viewport->size.width * scaling_3d_scale, 1, 16384);
+						height = CLAMP(p_viewport->size.height * scaling_3d_scale, 1, 16384);
+						render_width = width;
+						render_height = height;
+						break;
+					case RS::VIEWPORT_SCALING_3D_MODE_FSR:
+						width = p_viewport->size.width;
+						height = p_viewport->size.height;
+						render_width = MAX(width * scaling_3d_scale, 1.0); // width / (width * scaling)
+						render_height = MAX(height * scaling_3d_scale, 1.0);
+						break;
+					default:
+						// This is an unknown mode.
+						WARN_PRINT_ONCE(vformat("Unknown scaling mode: %d. Disabling 3D resolution scaling.", scaling_3d_mode));
+						width = p_viewport->size.width;
+						height = p_viewport->size.height;
+						render_width = width;
+						render_height = height;
+						break;
+				}
+			} else {
+				width = p_viewport->size.width;
+				height = p_viewport->size.height;
+				render_width = width;
+				render_height = height;
 			}
 
-			// Clamp 3D rendering resolution to reasonable values supported on most hardware.
-			// This prevents freezing the engine or outright crashing on lower-end GPUs.
-			const int width = CLAMP(p_viewport->size.width * scale_3d, 1, 16384);
-			const int height = CLAMP(p_viewport->size.height * scale_3d, 1, 16384);
-			RSG::scene->render_buffers_configure(p_viewport->render_buffers, p_viewport->render_target, width, height, p_viewport->msaa, p_viewport->screen_space_aa, p_viewport->use_debanding, p_viewport->get_view_count());
+			p_viewport->internal_size = Size2(render_width, render_height);
+
+			RSG::scene->render_buffers_configure(p_viewport->render_buffers, p_viewport->render_target, render_width, render_height, width, height, p_viewport->fsr_sharpness, p_viewport->fsr_mipmap_bias, p_viewport->msaa, p_viewport->screen_space_aa, p_viewport->use_debanding, p_viewport->get_view_count());
 		}
 	}
 }
@@ -116,8 +167,8 @@ void RendererViewport::_draw_3d(Viewport *p_viewport) {
 		}
 	}
 
-	float screen_lod_threshold = p_viewport->lod_threshold / float(p_viewport->size.width);
-	RSG::scene->render_camera(p_viewport->render_buffers, p_viewport->camera, p_viewport->scenario, p_viewport->self, p_viewport->size, screen_lod_threshold, p_viewport->shadow_atlas, xr_interface, &p_viewport->render_info);
+	float screen_mesh_lod_threshold = p_viewport->mesh_lod_threshold / float(p_viewport->size.width);
+	RSG::scene->render_camera(p_viewport->render_buffers, p_viewport->camera, p_viewport->scenario, p_viewport->self, p_viewport->internal_size, screen_mesh_lod_threshold, p_viewport->shadow_atlas, xr_interface, &p_viewport->render_info);
 
 	RENDER_TIMESTAMP("<End Rendering 3D Scene");
 }
@@ -129,6 +180,11 @@ void RendererViewport::_draw_viewport(Viewport *p_viewport) {
 		timestamp_vp_map[rt_id] = p_viewport->self;
 	}
 
+	if (OS::get_singleton()->get_current_rendering_driver_name() == "opengl3") {
+		// This is currently needed for GLES to keep the current window being rendered to up to date
+		DisplayServer::get_singleton()->gl_window_make_current(p_viewport->viewport_to_screen);
+	}
+
 	/* Camera should always be BEFORE any other 3D */
 
 	bool scenario_draw_canvas_bg = false; //draw canvas, or some layer of it, as BG for 3D instead of in front
@@ -495,9 +551,6 @@ void RendererViewport::draw_viewports() {
 
 	if (XRServer::get_singleton() != nullptr) {
 		xr_interface = XRServer::get_singleton()->get_primary_interface();
-
-		// process all our active interfaces
-		XRServer::get_singleton()->_process();
 	}
 
 	if (Engine::get_singleton()->is_editor_hint()) {
@@ -529,6 +582,21 @@ void RendererViewport::draw_viewports() {
 
 		bool visible = vp->viewport_to_screen_rect != Rect2();
 
+		if (vp->use_xr && xr_interface.is_valid()) {
+			visible = true; // XR viewport is always visible regardless of update mode, output is sent to HMD.
+
+			// Override our size, make sure it matches our required size and is created as a stereo target
+			Size2 xr_size = xr_interface->get_render_target_size();
+
+			// Would have been nice if we could call viewport_set_size here,
+			// but alas that takes our RID and we now have our pointer,
+			// also we only check if view_count changes in render_target_set_size so we need to call that for this to reliably change
+			vp->occlusion_buffer_dirty = vp->occlusion_buffer_dirty || (vp->size != xr_size);
+			vp->size = xr_size;
+			uint32_t view_count = xr_interface->get_view_count();
+			RSG::storage->render_target_set_size(vp->render_target, vp->size.x, vp->size.y, view_count);
+		}
+
 		if (vp->update_mode == RS::VIEWPORT_UPDATE_ALWAYS || vp->update_mode == RS::VIEWPORT_UPDATE_ONCE) {
 			visible = true;
 		}
@@ -566,11 +634,6 @@ void RendererViewport::draw_viewports() {
 
 		RSG::storage->render_target_set_as_unused(vp->render_target);
 		if (vp->use_xr && xr_interface.is_valid()) {
-			// override our size, make sure it matches our required size and is created as a stereo target
-			vp->size = xr_interface->get_render_target_size();
-			uint32_t view_count = xr_interface->get_view_count();
-			RSG::storage->render_target_set_size(vp->render_target, vp->size.x, vp->size.y, view_count);
-
 			// check for an external texture destination (disabled for now, not yet supported)
 			// RSG::storage->render_target_set_external_texture(vp->render_target, xr_interface->get_external_texture_for_eye(leftOrMono));
 			RSG::storage->render_target_set_external_texture(vp->render_target, 0);
@@ -660,6 +723,8 @@ void RendererViewport::viewport_initialize(RID p_rid) {
 	viewport->render_target = RSG::storage->render_target_create();
 	viewport->shadow_atlas = RSG::scene->shadow_atlas_create();
 	viewport->viewport_render_direct_to_screen = false;
+
+	viewport->fsr_enabled = !RSG::rasterizer->is_low_end() && !viewport->disable_3d;
 }
 
 void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
@@ -674,18 +739,42 @@ void RendererViewport::viewport_set_use_xr(RID p_viewport, bool p_use_xr) {
 	_configure_3d_render_buffers(viewport);
 }
 
-void RendererViewport::viewport_set_scale_3d(RID p_viewport, float p_scale_3d) {
+void RendererViewport::viewport_set_scaling_3d_mode(RID p_viewport, RS::ViewportScaling3DMode p_mode) {
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
+	ERR_FAIL_COND(!viewport);
+
+	viewport->scaling_3d_mode = p_mode;
+	_configure_3d_render_buffers(viewport);
+}
+
+void RendererViewport::viewport_set_fsr_sharpness(RID p_viewport, float p_sharpness) {
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
+	ERR_FAIL_COND(!viewport);
+
+	viewport->fsr_sharpness = p_sharpness;
+	_configure_3d_render_buffers(viewport);
+}
+
+void RendererViewport::viewport_set_fsr_mipmap_bias(RID p_viewport, float p_mipmap_bias) {
+	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
+	ERR_FAIL_COND(!viewport);
+
+	viewport->fsr_mipmap_bias = p_mipmap_bias;
+	_configure_3d_render_buffers(viewport);
+}
+
+void RendererViewport::viewport_set_scaling_3d_scale(RID p_viewport, float p_scaling_3d_scale) {
 	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
 	// Clamp to reasonable values that are actually useful.
 	// Values above 2.0 don't serve a practical purpose since the viewport
 	// isn't displayed with mipmaps.
-	if (viewport->scale_3d == CLAMP(p_scale_3d, 0.1, 2.0)) {
+	if (viewport->scaling_3d_scale == CLAMP(p_scaling_3d_scale, 0.1, 2.0)) {
 		return;
 	}
 
-	viewport->scale_3d = CLAMP(p_scale_3d, 0.1, 2.0);
+	viewport->scaling_3d_scale = CLAMP(p_scaling_3d_scale, 0.1, 2.0);
 	_configure_3d_render_buffers(viewport);
 }
 
@@ -711,6 +800,7 @@ void RendererViewport::viewport_set_size(RID p_viewport, int p_width, int p_heig
 	ERR_FAIL_COND(!viewport);
 
 	viewport->size = Size2(p_width, p_height);
+
 	uint32_t view_count = viewport->get_view_count();
 	RSG::storage->render_target_set_size(viewport->render_target, p_width, p_height, view_count);
 	_configure_3d_render_buffers(viewport);
@@ -750,7 +840,7 @@ void RendererViewport::viewport_attach_to_screen(RID p_viewport, const Rect2 &p_
 	ERR_FAIL_COND(!viewport);
 
 	if (p_screen != DisplayServer::INVALID_WINDOW_ID) {
-		// If using GLES2 we can optimize this operation by rendering directly to system_fbo
+		// If using OpenGL we can optimize this operation by rendering directly to system_fbo
 		// instead of rendering to fbo and copying to system_fbo after
 		if (RSG::rasterizer->is_low_end() && viewport->viewport_render_direct_to_screen) {
 			RSG::storage->render_target_set_size(viewport->render_target, p_rect.size.x, p_rect.size.y, viewport->get_view_count());
@@ -1004,14 +1094,15 @@ void RendererViewport::viewport_set_occlusion_culling_build_quality(RS::Viewport
 	RendererSceneOcclusionCull::get_singleton()->set_build_quality(p_quality);
 }
 
-void RendererViewport::viewport_set_lod_threshold(RID p_viewport, float p_pixels) {
+void RendererViewport::viewport_set_mesh_lod_threshold(RID p_viewport, float p_pixels) {
 	Viewport *viewport = viewport_owner.get_or_null(p_viewport);
 	ERR_FAIL_COND(!viewport);
 
-	viewport->lod_threshold = p_pixels;
+	viewport->mesh_lod_threshold = p_pixels;
 }
 
 int RendererViewport::viewport_get_render_info(RID p_viewport, RS::ViewportRenderInfoType p_type, RS::ViewportRenderInfo p_info) {
+	ERR_FAIL_INDEX_V(p_type, RS::VIEWPORT_RENDER_INFO_TYPE_MAX, -1);
 	ERR_FAIL_INDEX_V(p_info, RS::VIEWPORT_RENDER_INFO_MAX, -1);
 
 	Viewport *viewport = viewport_owner.get_or_null(p_viewport);