Optimized the way the process function works.

Author: AndreaCatania

core/net_utilities.cpp

@@ -16,9 +16,8 @@ int NS::PeerData::get_latency() const {
 	return int(compressed_latency) * 4;
 }
 
-void NS::PeerData::make_controller(NS::SceneSynchronizerBase &p_scene_sync, int p_peer) {
+void NS::PeerData::make_controller() {
 	controller = std::make_unique<NS::PeerNetworkedController>();
-	controller->setup_synchronizer(p_scene_sync, p_peer);
 }
 
 bool NS::SyncGroup::is_realtime_node_list_changed() const {

core/net_utilities.h

@@ -449,7 +449,7 @@ struct PeerData {
 	void set_compressed_latency(std::uint8_t p_compressed_latency) { compressed_latency = p_compressed_latency; }
 	std::uint8_t get_compressed_latency() const { return compressed_latency; }
 
-	void make_controller(class SceneSynchronizerBase &p_scene_sync, int p_peer);
+	void make_controller();
 	PeerNetworkedController *get_controller() {
 		return controller.get();
 	}
@@ -523,7 +523,7 @@ struct SyncGroup {
 
 public:
 	SyncGroupId group_id = SyncGroupId::NONE;
-	SceneSynchronizerBase *scene_sync = nullptr;
+	class SceneSynchronizerBase *scene_sync = nullptr;
 
 private:
 	bool simulated_sync_objects_list_changed = false;

core/peer_networked_controller.cpp

@@ -172,9 +172,11 @@ bool PeerNetworkedController::has_another_instant_to_process_after(int p_i) cons
 }
 
 void PeerNetworkedController::process(double p_delta) {
-	// This function is registered as processed function, so it's called by the
-	// `SceneSync` in sync with the scene processing.
-	controller->process(p_delta);
+	if make_likely (controller && can_simulate()) {
+		// This function is registered as processed function, so it's called by the
+		// `SceneSync` in sync with the scene processing.
+		controller->process(p_delta);
+	}
 }
 
 ServerController *PeerNetworkedController::get_server_controller() {

scene_synchronizer.cpp

@@ -919,7 +919,10 @@ void SceneSynchronizerBase::on_peer_connected(int p_peer) {
 		return;
 	}
 
-	pd_it->second.make_controller(*this, p_peer);
+	pd_it->second.make_controller();
+	pd_it->second.get_controller()->setup_synchronizer(*this, p_peer);
+	// Clear the process function because they need to be rebuild to include the new peer.
+	process_functions__clear();
 	reset_controller(*pd_it->second.get_controller());
 
 	event_peer_status_updated.broadcast(p_peer, true, true);
@@ -940,6 +943,9 @@ void SceneSynchronizerBase::on_peer_disconnected(int p_peer) {
 
 	peer_data.erase(p_peer);
 
+	// Clear the process function to make sure the peer process functions are removed.
+	process_functions__clear();
+
 #ifdef DEBUG_ENABLED
 	ASSERT_COND_MSG(peer_data.count(p_peer) <= 0, "The peer was just removed. This can't be triggered.");
 #endif
@@ -1386,11 +1392,29 @@ void SceneSynchronizerBase::process_functions__execute() {
 	NS_PROFILE_WITH_INFO(info);
 
 	if (cached_process_functions_valid == false) {
-		// Clear the process_functions.
+		// Clear all the process_functions.
 		for (int process_phase = PROCESS_PHASE_EARLY; process_phase < PROCESS_PHASE_COUNT; ++process_phase) {
 			cached_process_functions[process_phase].clear();
 		}
 
+		// Add a new process function for each peer
+		{
+			// Fetch the connected peers and sort them
+			std::vector<int> peers;
+			for (const auto &[peer, _] : peer_data) {
+				peers.push_back(peer);
+			}
+			std::sort(peers.begin(), peers.end());
+
+			// For each peer, add the process function.
+			for (int peer : peers) {
+				PeerNetworkedController *peer_controller = get_controller_for_peer(peer, false);
+				if (peer_controller) {
+					cached_process_functions[PROCESS_PHASE_PROCESS].bind(std::bind(&PeerNetworkedController::process, peer_controller, std::placeholders::_1));
+				}
+			}
+		}
+
 		// Build the cached_process_functions, making sure the node data order is kept.
 		for (auto od : objects_data_storage.get_sorted_objects_data()) {
 			if (od == nullptr || (is_client() && od->realtime_sync_enabled_on_client == false)) {
@@ -1411,27 +1435,7 @@ void SceneSynchronizerBase::process_functions__execute() {
 	SceneSynchronizerDebugger::singleton()->print(INFO, "Process functions START");
 
 	// Pre process phase
-	for (int process_phase = PROCESS_PHASE_EARLY; process_phase < PROCESS_PHASE_PROCESS; ++process_phase) {
-		const std::string info = "process phase: " + std::to_string(process_phase);
-		NS_PROFILE_WITH_INFO(info);
-		cached_process_functions[process_phase].broadcast(get_fixed_frame_delta());
-	}
-
-	// Controller process
-	{
-		const std::string info = "process phase -- CONTROLLER --";
-		NS_PROFILE_WITH_INFO(info);
-
-		// TODO optimize this, as `can_simulate` is expensive.
-		for (auto &pd : peer_data) {
-			if (pd.second.get_controller() && pd.second.get_controller()->can_simulate()) {
-				pd.second.get_controller()->process(get_fixed_frame_delta());
-			}
-		}
-	}
-
-	// Post process
-	for (int process_phase = PROCESS_PHASE_PROCESS; process_phase < PROCESS_PHASE_COUNT; ++process_phase) {
+	for (int process_phase = PROCESS_PHASE_EARLY; process_phase < PROCESS_PHASE_COUNT; ++process_phase) {
 		const std::string info = "process phase: " + std::to_string(process_phase);
 		NS_PROFILE_WITH_INFO(info);
 		cached_process_functions[process_phase].broadcast(get_fixed_frame_delta());