1 files changed, 184 insertions, 66 deletions

diff --git a/servers/rendering/rendering_server_default.cpp b/servers/rendering/rendering_server_default.cpp
index da6c3ef6f4..2ce9a20b6b 100644
--- a/servers/rendering/rendering_server_default.cpp
+++ b/servers/rendering/rendering_server_default.cpp
@@ -5,8 +5,8 @@
 /*                           GODOT ENGINE                                */
 /*                      https://godotengine.org                          */
 /*************************************************************************/
-/* Copyright (c) 2007-2020 Juan Linietsky, Ariel Manzur.                 */
-/* Copyright (c) 2014-2020 Godot Engine contributors (cf. AUTHORS.md).   */
+/* Copyright (c) 2007-2021 Juan Linietsky, Ariel Manzur.                 */
+/* Copyright (c) 2014-2021 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       */
@@ -38,33 +38,16 @@
 #include "renderer_scene_cull.h"
 #include "rendering_server_globals.h"
 
-// careful, these may run in different threads than the visual server
+// careful, these may run in different threads than the rendering server
 
 int RenderingServerDefault::changes = 0;
 
-/* BLACK BARS */
-
-void RenderingServerDefault::black_bars_set_margins(int p_left, int p_top, int p_right, int p_bottom) {
-	black_margin[SIDE_LEFT] = p_left;
-	black_margin[SIDE_TOP] = p_top;
-	black_margin[SIDE_RIGHT] = p_right;
-	black_margin[SIDE_BOTTOM] = p_bottom;
-}
-
-void RenderingServerDefault::black_bars_set_images(RID p_left, RID p_top, RID p_right, RID p_bottom) {
-	black_image[SIDE_LEFT] = p_left;
-	black_image[SIDE_TOP] = p_top;
-	black_image[SIDE_RIGHT] = p_right;
-	black_image[SIDE_BOTTOM] = p_bottom;
-}
-
-void RenderingServerDefault::_draw_margins() {
-	RSG::canvas_render->draw_window_margins(black_margin, black_image);
-};
-
 /* FREE */
 
-void RenderingServerDefault::free(RID p_rid) {
+void RenderingServerDefault::_free(RID p_rid) {
+	if (unlikely(p_rid.is_null())) {
+		return;
+	}
 	if (RSG::storage->free(p_rid)) {
 		return;
 	}
@@ -81,19 +64,13 @@ void RenderingServerDefault::free(RID p_rid) {
 
 /* EVENT QUEUING */
 
-void RenderingServerDefault::request_frame_drawn_callback(Object *p_where, const StringName &p_method, const Variant &p_userdata) {
-	ERR_FAIL_NULL(p_where);
-	FrameDrawnCallbacks fdc;
-	fdc.object = p_where->get_instance_id();
-	fdc.method = p_method;
-	fdc.param = p_userdata;
-
-	frame_drawn_callbacks.push_back(fdc);
+void RenderingServerDefault::request_frame_drawn_callback(const Callable &p_callable) {
+	frame_drawn_callbacks.push_back(p_callable);
 }
 
-void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
+void RenderingServerDefault::_draw(bool p_swap_buffers, double frame_step) {
 	//needs to be done before changes is reset to 0, to not force the editor to redraw
-	RS::get_singleton()->emit_signal("frame_pre_draw");
+	RS::get_singleton()->emit_signal(SNAME("frame_pre_draw"));
 
 	changes = 0;
 
@@ -114,24 +91,24 @@ void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
 	RSG::viewport->draw_viewports();
 	RSG::canvas_render->update();
 
-	_draw_margins();
 	RSG::rasterizer->end_frame(p_swap_buffers);
 
+	RSG::canvas->update_visibility_notifiers();
+	RSG::scene->update_visibility_notifiers();
+
 	while (frame_drawn_callbacks.front()) {
-		Object *obj = ObjectDB::get_instance(frame_drawn_callbacks.front()->get().object);
-		if (obj) {
-			Callable::CallError ce;
-			const Variant *v = &frame_drawn_callbacks.front()->get().param;
-			obj->call(frame_drawn_callbacks.front()->get().method, &v, 1, ce);
-			if (ce.error != Callable::CallError::CALL_OK) {
-				String err = Variant::get_call_error_text(obj, frame_drawn_callbacks.front()->get().method, &v, 1, ce);
-				ERR_PRINT("Error calling frame drawn function: " + err);
-			}
+		Callable c = frame_drawn_callbacks.front()->get();
+		Variant result;
+		Callable::CallError ce;
+		c.call(nullptr, 0, result, ce);
+		if (ce.error != Callable::CallError::CALL_OK) {
+			String err = Variant::get_callable_error_text(c, nullptr, 0, ce);
+			ERR_PRINT("Error calling frame drawn function: " + err);
 		}
 
 		frame_drawn_callbacks.pop_front();
 	}
-	RS::get_singleton()->emit_signal("frame_post_draw");
+	RS::get_singleton()->emit_signal(SNAME("frame_post_draw"));
 
 	if (RSG::storage->get_captured_timestamps_count()) {
 		Vector<FrameProfileArea> new_profile;
@@ -152,8 +129,8 @@ void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
 			}
 
 			if (RSG::storage->capturing_timestamps) {
-				new_profile.write[i].gpu_msec = float((time_gpu - base_gpu) / 1000) / 1000.0;
-				new_profile.write[i].cpu_msec = float(time_cpu - base_cpu) / 1000.0;
+				new_profile.write[i].gpu_msec = double((time_gpu - base_gpu) / 1000) / 1000.0;
+				new_profile.write[i].cpu_msec = double(time_cpu - base_cpu) / 1000.0;
 				new_profile.write[i].name = RSG::storage->get_captured_timestamp_name(i);
 			}
 		}
@@ -162,24 +139,68 @@ void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
 	}
 
 	frame_profile_frame = RSG::storage->get_captured_timestamps_frame();
-}
 
-float RenderingServerDefault::get_frame_setup_time_cpu() const {
-	return frame_setup_time;
+	if (print_gpu_profile) {
+		if (print_frame_profile_ticks_from == 0) {
+			print_frame_profile_ticks_from = OS::get_singleton()->get_ticks_usec();
+		}
+		double total_time = 0.0;
+
+		for (int i = 0; i < frame_profile.size() - 1; i++) {
+			String name = frame_profile[i].name;
+			if (name[0] == '<' || name[0] == '>') {
+				continue;
+			}
+
+			double time = frame_profile[i + 1].gpu_msec - frame_profile[i].gpu_msec;
+
+			if (name[0] != '<' && name[0] != '>') {
+				if (print_gpu_profile_task_time.has(name)) {
+					print_gpu_profile_task_time[name] += time;
+				} else {
+					print_gpu_profile_task_time[name] = time;
+				}
+			}
+		}
+
+		if (frame_profile.size()) {
+			total_time = frame_profile[frame_profile.size() - 1].gpu_msec;
+		}
+
+		uint64_t ticks_elapsed = OS::get_singleton()->get_ticks_usec() - print_frame_profile_ticks_from;
+		print_frame_profile_frame_count++;
+		if (ticks_elapsed > 1000000) {
+			print_line("GPU PROFILE (total " + rtos(total_time) + "ms): ");
+
+			float print_threshold = 0.01;
+			for (OrderedHashMap<String, float>::Element E = print_gpu_profile_task_time.front(); E; E = E.next()) {
+				double time = E.value() / double(print_frame_profile_frame_count);
+				if (time > print_threshold) {
+					print_line("\t-" + E.key() + ": " + rtos(time) + "ms");
+				}
+			}
+			print_gpu_profile_task_time.clear();
+			print_frame_profile_ticks_from = OS::get_singleton()->get_ticks_usec();
+			print_frame_profile_frame_count = 0;
+		}
+	}
+
+	RSG::storage->update_memory_info();
 }
 
-void RenderingServerDefault::sync() {
+double RenderingServerDefault::get_frame_setup_time_cpu() const {
+	return frame_setup_time;
 }
 
 bool RenderingServerDefault::has_changed() const {
 	return changes > 0;
 }
 
-void RenderingServerDefault::init() {
+void RenderingServerDefault::_init() {
 	RSG::rasterizer->initialize();
 }
 
-void RenderingServerDefault::finish() {
+void RenderingServerDefault::_finish() {
 	if (test_cube.is_valid()) {
 		free(test_cube);
 	}
@@ -187,10 +208,43 @@ void RenderingServerDefault::finish() {
 	RSG::rasterizer->finalize();
 }
 
+void RenderingServerDefault::init() {
+	if (create_thread) {
+		print_verbose("RenderingServerWrapMT: Creating render thread");
+		DisplayServer::get_singleton()->release_rendering_thread();
+		if (create_thread) {
+			thread.start(_thread_callback, this);
+			print_verbose("RenderingServerWrapMT: Starting render thread");
+		}
+		while (!draw_thread_up.is_set()) {
+			OS::get_singleton()->delay_usec(1000);
+		}
+		print_verbose("RenderingServerWrapMT: Finished render thread");
+	} else {
+		_init();
+	}
+}
+
+void RenderingServerDefault::finish() {
+	if (create_thread) {
+		command_queue.push(this, &RenderingServerDefault::_thread_exit);
+		thread.wait_to_finish();
+	} else {
+		_finish();
+	}
+}
+
 /* STATUS INFORMATION */
 
-int RenderingServerDefault::get_render_info(RenderInfo p_info) {
-	return RSG::storage->get_render_info(p_info);
+uint64_t RenderingServerDefault::get_rendering_info(RenderingInfo p_info) {
+	if (p_info == RENDERING_INFO_TOTAL_OBJECTS_IN_FRAME) {
+		return RSG::viewport->get_total_objects_drawn();
+	} else if (p_info == RENDERING_INFO_TOTAL_PRIMITIVES_IN_FRAME) {
+		return RSG::viewport->get_total_vertices_drawn();
+	} else if (p_info == RENDERING_INFO_TOTAL_DRAW_CALLS_IN_FRAME) {
+		return RSG::viewport->get_total_draw_calls_used();
+	}
+	return RSG::storage->get_rendering_info(p_info);
 }
 
 String RenderingServerDefault::get_video_adapter_name() const {
@@ -232,6 +286,11 @@ void RenderingServerDefault::sdfgi_set_debug_probe_select(const Vector3 &p_posit
 	RSG::scene->sdfgi_set_debug_probe_select(p_position, p_dir);
 }
 
+void RenderingServerDefault::set_print_gpu_profile(bool p_enable) {
+	RSG::storage->capturing_timestamps = p_enable;
+	print_gpu_profile = p_enable;
+}
+
 RID RenderingServerDefault::get_test_cube() {
 	if (!test_cube.is_valid()) {
 		test_cube = _make_test_cube();
@@ -247,10 +306,6 @@ void RenderingServerDefault::set_debug_generate_wireframes(bool p_generate) {
 	RSG::storage->set_debug_generate_wireframes(p_generate);
 }
 
-void RenderingServerDefault::call_set_use_vsync(bool p_enable) {
-	DisplayServer::get_singleton()->_set_use_vsync(p_enable);
-}
-
 bool RenderingServerDefault::is_low_end() const {
 	// FIXME: Commented out when rebasing vulkan branch on master,
 	// causes a crash, it seems rasterizer is not initialized yet the
@@ -259,7 +314,75 @@ bool RenderingServerDefault::is_low_end() const {
 	return false;
 }
 
-RenderingServerDefault::RenderingServerDefault() {
+void RenderingServerDefault::_thread_exit() {
+	exit.set();
+}
+
+void RenderingServerDefault::_thread_draw(bool p_swap_buffers, double frame_step) {
+	if (!draw_pending.decrement()) {
+		_draw(p_swap_buffers, frame_step);
+	}
+}
+
+void RenderingServerDefault::_thread_flush() {
+	draw_pending.decrement();
+}
+
+void RenderingServerDefault::_thread_callback(void *_instance) {
+	RenderingServerDefault *vsmt = reinterpret_cast<RenderingServerDefault *>(_instance);
+
+	vsmt->_thread_loop();
+}
+
+void RenderingServerDefault::_thread_loop() {
+	server_thread = Thread::get_caller_id();
+
+	DisplayServer::get_singleton()->make_rendering_thread();
+
+	_init();
+
+	draw_thread_up.set();
+	while (!exit.is_set()) {
+		// flush commands one by one, until exit is requested
+		command_queue.wait_and_flush();
+	}
+
+	command_queue.flush_all(); // flush all
+
+	_finish();
+}
+
+/* EVENT QUEUING */
+
+void RenderingServerDefault::sync() {
+	if (create_thread) {
+		draw_pending.increment();
+		command_queue.push_and_sync(this, &RenderingServerDefault::_thread_flush);
+	} else {
+		command_queue.flush_all(); //flush all pending from other threads
+	}
+}
+
+void RenderingServerDefault::draw(bool p_swap_buffers, double frame_step) {
+	if (create_thread) {
+		draw_pending.increment();
+		command_queue.push(this, &RenderingServerDefault::_thread_draw, p_swap_buffers, frame_step);
+	} else {
+		_draw(p_swap_buffers, frame_step);
+	}
+}
+
+RenderingServerDefault::RenderingServerDefault(bool p_create_thread) :
+		command_queue(p_create_thread) {
+	create_thread = p_create_thread;
+
+	if (!p_create_thread) {
+		server_thread = Thread::get_caller_id();
+	} else {
+		server_thread = 0;
+	}
+
+	RSG::threaded = p_create_thread;
 	RSG::canvas = memnew(RendererCanvasCull);
 	RSG::viewport = memnew(RendererViewport);
 	RendererSceneCull *sr = memnew(RendererSceneCull);
@@ -267,14 +390,9 @@ RenderingServerDefault::RenderingServerDefault() {
 	RSG::rasterizer = RendererCompositor::create();
 	RSG::storage = RSG::rasterizer->get_storage();
 	RSG::canvas_render = RSG::rasterizer->get_canvas();
-	sr->scene_render = RSG::rasterizer->get_scene();
+	sr->set_scene_render(RSG::rasterizer->get_scene());
 
 	frame_profile_frame = 0;
-
-	for (int i = 0; i < 4; i++) {
-		black_margin[i] = 0;
-		black_image[i] = RID();
-	}
 }
 
 RenderingServerDefault::~RenderingServerDefault() {