Merge pull request #57646 from Faless/mp/4.x_interfaces

[Net] Move RPC, Node cache out of MultiplayerAPI.

7 files changed, 945 insertions, 11 deletions

diff --git a/scene/main/scene_tree.cpp b/scene/main/scene_tree.cpp
index 0e4a6a4b5c..69d781cbfc 100644
--- a/scene/main/scene_tree.cpp
+++ b/scene/main/scene_tree.cpp
@@ -1165,7 +1165,7 @@ void SceneTree::set_multiplayer(Ref<MultiplayerAPI> p_multiplayer) {
 	ERR_FAIL_COND(!p_multiplayer.is_valid());
 
 	multiplayer = p_multiplayer;
-	multiplayer->set_root_node(root);
+	multiplayer->set_root_path("/" + root->get_name());
 }
 
 void SceneTree::_bind_methods() {
diff --git a/scene/multiplayer/scene_cache_interface.cpp b/scene/multiplayer/scene_cache_interface.cpp
new file mode 100644
index 0000000000..de4a94470a
--- /dev/null
+++ b/scene/multiplayer/scene_cache_interface.cpp
@@ -0,0 +1,249 @@
+/*************************************************************************/
+/*  scene_cache_interface.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.                */
+/*************************************************************************/
+
+#include "scene_cache_interface.h"
+
+#include "core/io/marshalls.h"
+#include "scene/main/node.h"
+#include "scene/main/window.h"
+
+MultiplayerCacheInterface *SceneCacheInterface::_create(MultiplayerAPI *p_multiplayer) {
+	return memnew(SceneCacheInterface(p_multiplayer));
+}
+
+void SceneCacheInterface::make_default() {
+	MultiplayerAPI::create_default_cache_interface = _create;
+}
+
+void SceneCacheInterface::on_peer_change(int p_id, bool p_connected) {
+	if (p_connected) {
+		path_get_cache.insert(p_id, PathGetCache());
+	} else {
+		// Cleanup get cache.
+		path_get_cache.erase(p_id);
+		// Cleanup sent cache.
+		// Some refactoring is needed to make this faster and do paths GC.
+		List<NodePath> keys;
+		path_send_cache.get_key_list(&keys);
+		for (const NodePath &E : keys) {
+			PathSentCache *psc = path_send_cache.getptr(E);
+			psc->confirmed_peers.erase(p_id);
+		}
+	}
+}
+
+void SceneCacheInterface::process_simplify_path(int p_from, const uint8_t *p_packet, int p_packet_len) {
+	Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
+	ERR_FAIL_COND(!root_node);
+	ERR_FAIL_COND_MSG(p_packet_len < 38, "Invalid packet received. Size too small.");
+	int ofs = 1;
+
+	String methods_md5;
+	methods_md5.parse_utf8((const char *)(p_packet + ofs), 32);
+	ofs += 33;
+
+	int id = decode_uint32(&p_packet[ofs]);
+	ofs += 4;
+
+	String paths;
+	paths.parse_utf8((const char *)(p_packet + ofs), p_packet_len - ofs);
+
+	NodePath path = paths;
+
+	if (!path_get_cache.has(p_from)) {
+		path_get_cache[p_from] = PathGetCache();
+	}
+
+	Node *node = root_node->get_node(path);
+	ERR_FAIL_COND(node == nullptr);
+	const bool valid_rpc_checksum = multiplayer->get_rpc_md5(node) == methods_md5;
+	if (valid_rpc_checksum == false) {
+		ERR_PRINT("The rpc node checksum failed. Make sure to have the same methods on both nodes. Node path: " + path);
+	}
+
+	PathGetCache::NodeInfo ni;
+	ni.path = path;
+
+	path_get_cache[p_from].nodes[id] = ni;
+
+	// Encode path to send ack.
+	CharString pname = String(path).utf8();
+	int len = encode_cstring(pname.get_data(), nullptr);
+
+	Vector<uint8_t> packet;
+
+	packet.resize(1 + 1 + len);
+	packet.write[0] = MultiplayerAPI::NETWORK_COMMAND_CONFIRM_PATH;
+	packet.write[1] = valid_rpc_checksum;
+	encode_cstring(pname.get_data(), &packet.write[2]);
+
+	Ref<MultiplayerPeer> multiplayer_peer = multiplayer->get_multiplayer_peer();
+	ERR_FAIL_COND(multiplayer_peer.is_null());
+
+	multiplayer_peer->set_transfer_channel(0);
+	multiplayer_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+	multiplayer_peer->set_target_peer(p_from);
+	multiplayer_peer->put_packet(packet.ptr(), packet.size());
+}
+
+void SceneCacheInterface::process_confirm_path(int p_from, const uint8_t *p_packet, int p_packet_len) {
+	ERR_FAIL_COND_MSG(p_packet_len < 3, "Invalid packet received. Size too small.");
+
+	const bool valid_rpc_checksum = p_packet[1];
+
+	String paths;
+	paths.parse_utf8((const char *)&p_packet[2], p_packet_len - 2);
+
+	NodePath path = paths;
+
+	if (valid_rpc_checksum == false) {
+		ERR_PRINT("The rpc node checksum failed. Make sure to have the same methods on both nodes. Node path: " + path);
+	}
+
+	PathSentCache *psc = path_send_cache.getptr(path);
+	ERR_FAIL_COND_MSG(!psc, "Invalid packet received. Tries to confirm a path which was not found in cache.");
+
+	Map<int, bool>::Element *E = psc->confirmed_peers.find(p_from);
+	ERR_FAIL_COND_MSG(!E, "Invalid packet received. Source peer was not found in cache for the given path.");
+	E->get() = true;
+}
+
+bool SceneCacheInterface::_send_confirm_path(Node *p_node, NodePath p_path, PathSentCache *psc, int p_target) {
+	bool has_all_peers = true;
+	List<int> peers_to_add; // If one is missing, take note to add it.
+
+	for (const Set<int>::Element *E = multiplayer->get_connected_peers().front(); E; E = E->next()) {
+		if (p_target < 0 && E->get() == -p_target) {
+			continue; // Continue, excluded.
+		}
+
+		if (p_target > 0 && E->get() != p_target) {
+			continue; // Continue, not for this peer.
+		}
+
+		Map<int, bool>::Element *F = psc->confirmed_peers.find(E->get());
+
+		if (!F || !F->get()) {
+			// Path was not cached, or was cached but is unconfirmed.
+			if (!F) {
+				// Not cached at all, take note.
+				peers_to_add.push_back(E->get());
+			}
+
+			has_all_peers = false;
+		}
+	}
+
+	if (peers_to_add.size() > 0) {
+		// Those that need to be added, send a message for this.
+
+		// Encode function name.
+		const CharString path = String(p_path).utf8();
+		const int path_len = encode_cstring(path.get_data(), nullptr);
+
+		// Extract MD5 from rpc methods list.
+		const String methods_md5 = multiplayer->get_rpc_md5(p_node);
+		const int methods_md5_len = 33; // 32 + 1 for the `0` that is added by the encoder.
+
+		Vector<uint8_t> packet;
+		packet.resize(1 + 4 + path_len + methods_md5_len);
+		int ofs = 0;
+
+		packet.write[ofs] = MultiplayerAPI::NETWORK_COMMAND_SIMPLIFY_PATH;
+		ofs += 1;
+
+		ofs += encode_cstring(methods_md5.utf8().get_data(), &packet.write[ofs]);
+
+		ofs += encode_uint32(psc->id, &packet.write[ofs]);
+
+		ofs += encode_cstring(path.get_data(), &packet.write[ofs]);
+
+		Ref<MultiplayerPeer> multiplayer_peer = multiplayer->get_multiplayer_peer();
+		ERR_FAIL_COND_V(multiplayer_peer.is_null(), false);
+
+		for (int &E : peers_to_add) {
+			multiplayer_peer->set_target_peer(E); // To all of you.
+			multiplayer_peer->set_transfer_channel(0);
+			multiplayer_peer->set_transfer_mode(Multiplayer::TRANSFER_MODE_RELIABLE);
+			multiplayer_peer->put_packet(packet.ptr(), packet.size());
+
+			psc->confirmed_peers.insert(E, false); // Insert into confirmed, but as false since it was not confirmed.
+		}
+	}
+
+	return has_all_peers;
+}
+
+bool SceneCacheInterface::is_cache_confirmed(NodePath p_path, int p_peer) {
+	const PathSentCache *psc = path_send_cache.getptr(p_path);
+	ERR_FAIL_COND_V(!psc, false);
+	const Map<int, bool>::Element *F = psc->confirmed_peers.find(p_peer);
+	ERR_FAIL_COND_V(!F, false); // Should never happen.
+	return F->get();
+}
+
+bool SceneCacheInterface::send_object_cache(Object *p_obj, NodePath p_path, int p_peer_id, int &r_id) {
+	Node *node = Object::cast_to<Node>(p_obj);
+	ERR_FAIL_COND_V(!node, false);
+	// See if the path is cached.
+	PathSentCache *psc = path_send_cache.getptr(p_path);
+	if (!psc) {
+		// Path is not cached, create.
+		path_send_cache[p_path] = PathSentCache();
+		psc = path_send_cache.getptr(p_path);
+		psc->id = last_send_cache_id++;
+	}
+	r_id = psc->id;
+
+	return _send_confirm_path(node, p_path, psc, p_peer_id);
+}
+
+Object *SceneCacheInterface::get_cached_object(int p_from, uint32_t p_cache_id) {
+	Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
+	ERR_FAIL_COND_V(!root_node, nullptr);
+	Map<int, PathGetCache>::Element *E = path_get_cache.find(p_from);
+	ERR_FAIL_COND_V_MSG(!E, nullptr, vformat("No cache found for peer %d.", p_from));
+
+	Map<int, PathGetCache::NodeInfo>::Element *F = E->get().nodes.find(p_cache_id);
+	ERR_FAIL_COND_V_MSG(!F, nullptr, vformat("ID %d not found in cache of peer %d.", p_cache_id, p_from));
+
+	PathGetCache::NodeInfo *ni = &F->get();
+	Node *node = root_node->get_node(ni->path);
+	if (!node) {
+		ERR_PRINT("Failed to get cached path: " + String(ni->path) + ".");
+	}
+	return node;
+}
+
+void SceneCacheInterface::clear() {
+	path_get_cache.clear();
+	path_send_cache.clear();
+	last_send_cache_id = 1;
+}
diff --git a/scene/multiplayer/scene_cache_interface.h b/scene/multiplayer/scene_cache_interface.h
new file mode 100644
index 0000000000..91a53cb948
--- /dev/null
+++ b/scene/multiplayer/scene_cache_interface.h
@@ -0,0 +1,82 @@
+/*************************************************************************/
+/*  scene_cache_interface.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 SCENE_CACHE_INTERFACE_H
+#define SCENE_CACHE_INTERFACE_H
+
+#include "core/multiplayer/multiplayer_api.h"
+
+class SceneCacheInterface : public MultiplayerCacheInterface {
+	GDCLASS(SceneCacheInterface, MultiplayerCacheInterface);
+
+private:
+	MultiplayerAPI *multiplayer;
+
+	//path sent caches
+	struct PathSentCache {
+		Map<int, bool> confirmed_peers;
+		int id;
+	};
+
+	//path get caches
+	struct PathGetCache {
+		struct NodeInfo {
+			NodePath path;
+			ObjectID instance;
+		};
+
+		Map<int, NodeInfo> nodes;
+	};
+
+	HashMap<NodePath, PathSentCache> path_send_cache;
+	Map<int, PathGetCache> path_get_cache;
+	int last_send_cache_id = 1;
+
+protected:
+	bool _send_confirm_path(Node *p_node, NodePath p_path, PathSentCache *psc, int p_target);
+	static MultiplayerCacheInterface *_create(MultiplayerAPI *p_multiplayer);
+
+public:
+	static void make_default();
+
+	virtual void clear() override;
+	virtual void on_peer_change(int p_id, bool p_connected) override;
+	virtual void process_simplify_path(int p_from, const uint8_t *p_packet, int p_packet_len) override;
+	virtual void process_confirm_path(int p_from, const uint8_t *p_packet, int p_packet_len) override;
+
+	// Returns true if all peers have cached path.
+	virtual bool send_object_cache(Object *p_obj, NodePath p_path, int p_target, int &p_id) override;
+	virtual Object *get_cached_object(int p_from, uint32_t p_cache_id) override;
+	virtual bool is_cache_confirmed(NodePath p_path, int p_peer) override;
+
+	SceneCacheInterface(MultiplayerAPI *p_multiplayer) { multiplayer = p_multiplayer; }
+};
+
+#endif // SCENE_CACHE_INTERFACE_H
diff --git a/scene/multiplayer/scene_replication_interface.cpp b/scene/multiplayer/scene_replication_interface.cpp
index 7155935084..2088a43ba7 100644
--- a/scene/multiplayer/scene_replication_interface.cpp
+++ b/scene/multiplayer/scene_replication_interface.cpp
@@ -186,12 +186,10 @@ Error SceneReplicationInterface::_send_spawn(Node *p_node, MultiplayerSpawner *p
 	}
 
 	// Prepare simplified path.
-	const Node *root_node = multiplayer->get_root_node();
-	ERR_FAIL_COND_V(!root_node, ERR_UNCONFIGURED);
-	NodePath rel_path = (root_node->get_path()).rel_path_to(p_spawner->get_path());
+	NodePath rel_path = multiplayer->get_root_path().rel_path_to(p_spawner->get_path());
 
 	int path_id = 0;
-	multiplayer->send_confirm_path(p_spawner, rel_path, p_peer, path_id);
+	multiplayer->send_object_cache(p_spawner, rel_path, p_peer, path_id);
 
 	// Encode name and parent ID.
 	CharString cname = p_node->get_name().operator String().utf8();
@@ -243,7 +241,7 @@ Error SceneReplicationInterface::on_spawn_receive(int p_from, const uint8_t *p_b
 	ofs += 1;
 	uint32_t node_target = decode_uint32(&p_buffer[ofs]);
 	ofs += 4;
-	MultiplayerSpawner *spawner = Object::cast_to<MultiplayerSpawner>(multiplayer->get_cached_node(p_from, node_target));
+	MultiplayerSpawner *spawner = Object::cast_to<MultiplayerSpawner>(multiplayer->get_cached_object(p_from, node_target));
 	ERR_FAIL_COND_V(!spawner, ERR_DOES_NOT_EXIST);
 	ERR_FAIL_COND_V(p_from != spawner->get_multiplayer_authority(), ERR_UNAUTHORIZED);
 
@@ -349,11 +347,9 @@ void SceneReplicationInterface::_send_sync(int p_peer, uint64_t p_msec) {
 			uint32_t net_id = rep_state->get_net_id(oid);
 			if (net_id == 0) {
 				// First time path based ID.
-				const Node *root_node = multiplayer->get_root_node();
-				ERR_FAIL_COND(!root_node);
-				NodePath rel_path = (root_node->get_path()).rel_path_to(sync->get_path());
+				NodePath rel_path = multiplayer->get_root_path().rel_path_to(sync->get_path());
 				int path_id = 0;
-				multiplayer->send_confirm_path(sync, rel_path, p_peer, path_id);
+				multiplayer->send_object_cache(sync, rel_path, p_peer, path_id);
 				net_id = path_id;
 				rep_state->set_net_id(oid, net_id | 0x80000000);
 			}
@@ -381,7 +377,7 @@ Error SceneReplicationInterface::on_sync_receive(int p_from, const uint8_t *p_bu
 		ofs += 4;
 		Node *node = nullptr;
 		if (net_id & 0x80000000) {
-			MultiplayerSynchronizer *sync = Object::cast_to<MultiplayerSynchronizer>(multiplayer->get_cached_node(p_from, net_id & 0x7FFFFFFF));
+			MultiplayerSynchronizer *sync = Object::cast_to<MultiplayerSynchronizer>(multiplayer->get_cached_object(p_from, net_id & 0x7FFFFFFF));
 			ERR_FAIL_COND_V(!sync || sync->get_multiplayer_authority() != p_from, ERR_UNAUTHORIZED);
 			node = sync->get_node(sync->get_root_path());
 		} else {
diff --git a/scene/multiplayer/scene_rpc_interface.cpp b/scene/multiplayer/scene_rpc_interface.cpp
new file mode 100644
index 0000000000..7d7f57b9a1
--- /dev/null
+++ b/scene/multiplayer/scene_rpc_interface.cpp
@@ -0,0 +1,512 @@
+/*************************************************************************/
+/*  scene_rpc_interface.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.                */
+/*************************************************************************/
+
+#include "scene/multiplayer/scene_rpc_interface.h"
+
+#include "core/debugger/engine_debugger.h"
+#include "core/io/marshalls.h"
+#include "core/multiplayer/multiplayer_api.h"
+#include "scene/main/node.h"
+#include "scene/main/window.h"
+
+MultiplayerRPCInterface *SceneRPCInterface::_create(MultiplayerAPI *p_multiplayer) {
+	return memnew(SceneRPCInterface(p_multiplayer));
+}
+
+void SceneRPCInterface::make_default() {
+	MultiplayerAPI::create_default_rpc_interface = _create;
+}
+
+#ifdef DEBUG_ENABLED
+_FORCE_INLINE_ void SceneRPCInterface::_profile_node_data(const String &p_what, ObjectID p_id) {
+	if (EngineDebugger::is_profiling("multiplayer")) {
+		Array values;
+		values.push_back("node");
+		values.push_back(p_id);
+		values.push_back(p_what);
+		EngineDebugger::profiler_add_frame_data("multiplayer", values);
+	}
+}
+#else
+_FORCE_INLINE_ void SceneRPCInterface::_profile_node_data(const String &p_what, ObjectID p_id) {}
+#endif
+
+// Returns the packet size stripping the node path added when the node is not yet cached.
+int get_packet_len(uint32_t p_node_target, int p_packet_len) {
+	if (p_node_target & 0x80000000) {
+		int ofs = p_node_target & 0x7FFFFFFF;
+		return p_packet_len - (p_packet_len - ofs);
+	} else {
+		return p_packet_len;
+	}
+}
+
+const Multiplayer::RPCConfig _get_rpc_config(const Node *p_node, const StringName &p_method, uint16_t &r_id) {
+	const Vector<Multiplayer::RPCConfig> node_config = p_node->get_node_rpc_methods();
+	for (int i = 0; i < node_config.size(); i++) {
+		if (node_config[i].name == p_method) {
+			r_id = ((uint16_t)i) | (1 << 15);
+			return node_config[i];
+		}
+	}
+	if (p_node->get_script_instance()) {
+		const Vector<Multiplayer::RPCConfig> script_config = p_node->get_script_instance()->get_rpc_methods();
+		for (int i = 0; i < script_config.size(); i++) {
+			if (script_config[i].name == p_method) {
+				r_id = (uint16_t)i;
+				return script_config[i];
+			}
+		}
+	}
+	return Multiplayer::RPCConfig();
+}
+
+const Multiplayer::RPCConfig _get_rpc_config_by_id(Node *p_node, uint16_t p_id) {
+	Vector<Multiplayer::RPCConfig> config;
+	uint16_t id = p_id;
+	if (id & (1 << 15)) {
+		id = id & ~(1 << 15);
+		config = p_node->get_node_rpc_methods();
+	} else if (p_node->get_script_instance()) {
+		config = p_node->get_script_instance()->get_rpc_methods();
+	}
+	if (id < config.size()) {
+		return config[id];
+	}
+	return Multiplayer::RPCConfig();
+}
+
+_FORCE_INLINE_ bool _can_call_mode(Node *p_node, Multiplayer::RPCMode mode, int p_remote_id) {
+	switch (mode) {
+		case Multiplayer::RPC_MODE_DISABLED: {
+			return false;
+		} break;
+		case Multiplayer::RPC_MODE_ANY_PEER: {
+			return true;
+		} break;
+		case Multiplayer::RPC_MODE_AUTHORITY: {
+			return !p_node->is_multiplayer_authority() && p_remote_id == p_node->get_multiplayer_authority();
+		} break;
+	}
+
+	return false;
+}
+
+String SceneRPCInterface::get_rpc_md5(const Object *p_obj) const {
+	const Node *node = Object::cast_to<Node>(p_obj);
+	ERR_FAIL_COND_V(!node, "");
+	String rpc_list;
+	const Vector<Multiplayer::RPCConfig> node_config = node->get_node_rpc_methods();
+	for (int i = 0; i < node_config.size(); i++) {
+		rpc_list += String(node_config[i].name);
+	}
+	if (node->get_script_instance()) {
+		const Vector<Multiplayer::RPCConfig> script_config = node->get_script_instance()->get_rpc_methods();
+		for (int i = 0; i < script_config.size(); i++) {
+			rpc_list += String(script_config[i].name);
+		}
+	}
+	return rpc_list.md5_text();
+}
+
+Node *SceneRPCInterface::_process_get_node(int p_from, const uint8_t *p_packet, uint32_t p_node_target, int p_packet_len) {
+	Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
+	ERR_FAIL_COND_V(!root_node, nullptr);
+	Node *node = nullptr;
+
+	if (p_node_target & 0x80000000) {
+		// Use full path (not cached yet).
+		int ofs = p_node_target & 0x7FFFFFFF;
+
+		ERR_FAIL_COND_V_MSG(ofs >= p_packet_len, nullptr, "Invalid packet received. Size smaller than declared.");
+
+		String paths;
+		paths.parse_utf8((const char *)&p_packet[ofs], p_packet_len - ofs);
+
+		NodePath np = paths;
+
+		node = root_node->get_node(np);
+
+		if (!node) {
+			ERR_PRINT("Failed to get path from RPC: " + String(np) + ".");
+		}
+		return node;
+	} else {
+		// Use cached path.
+		return Object::cast_to<Node>(multiplayer->get_cached_object(p_from, p_node_target));
+	}
+}
+
+void SceneRPCInterface::process_rpc(int p_from, const uint8_t *p_packet, int p_packet_len) {
+	// Extract packet meta
+	int packet_min_size = 1;
+	int name_id_offset = 1;
+	ERR_FAIL_COND_MSG(p_packet_len < packet_min_size, "Invalid packet received. Size too small.");
+	// Compute the meta size, which depends on the compression level.
+	int node_id_compression = (p_packet[0] & NODE_ID_COMPRESSION_FLAG) >> NODE_ID_COMPRESSION_SHIFT;
+	int name_id_compression = (p_packet[0] & NAME_ID_COMPRESSION_FLAG) >> NAME_ID_COMPRESSION_SHIFT;
+
+	switch (node_id_compression) {
+		case NETWORK_NODE_ID_COMPRESSION_8:
+			packet_min_size += 1;
+			name_id_offset += 1;
+			break;
+		case NETWORK_NODE_ID_COMPRESSION_16:
+			packet_min_size += 2;
+			name_id_offset += 2;
+			break;
+		case NETWORK_NODE_ID_COMPRESSION_32:
+			packet_min_size += 4;
+			name_id_offset += 4;
+			break;
+		default:
+			ERR_FAIL_MSG("Was not possible to extract the node id compression mode.");
+	}
+	switch (name_id_compression) {
+		case NETWORK_NAME_ID_COMPRESSION_8:
+			packet_min_size += 1;
+			break;
+		case NETWORK_NAME_ID_COMPRESSION_16:
+			packet_min_size += 2;
+			break;
+		default:
+			ERR_FAIL_MSG("Was not possible to extract the name id compression mode.");
+	}
+	ERR_FAIL_COND_MSG(p_packet_len < packet_min_size, "Invalid packet received. Size too small.");
+
+	uint32_t node_target = 0;
+	switch (node_id_compression) {
+		case NETWORK_NODE_ID_COMPRESSION_8:
+			node_target = p_packet[1];
+			break;
+		case NETWORK_NODE_ID_COMPRESSION_16:
+			node_target = decode_uint16(p_packet + 1);
+			break;
+		case NETWORK_NODE_ID_COMPRESSION_32:
+			node_target = decode_uint32(p_packet + 1);
+			break;
+		default:
+			// Unreachable, checked before.
+			CRASH_NOW();
+	}
+
+	Node *node = _process_get_node(p_from, p_packet, node_target, p_packet_len);
+	ERR_FAIL_COND_MSG(node == nullptr, "Invalid packet received. Requested node was not found.");
+
+	uint16_t name_id = 0;
+	switch (name_id_compression) {
+		case NETWORK_NAME_ID_COMPRESSION_8:
+			name_id = p_packet[name_id_offset];
+			break;
+		case NETWORK_NAME_ID_COMPRESSION_16:
+			name_id = decode_uint16(p_packet + name_id_offset);
+			break;
+		default:
+			// Unreachable, checked before.
+			CRASH_NOW();
+	}
+
+	const int packet_len = get_packet_len(node_target, p_packet_len);
+	_process_rpc(node, name_id, p_from, p_packet, packet_len, packet_min_size);
+}
+
+void SceneRPCInterface::_process_rpc(Node *p_node, const uint16_t p_rpc_method_id, int p_from, const uint8_t *p_packet, int p_packet_len, int p_offset) {
+	ERR_FAIL_COND_MSG(p_offset > p_packet_len, "Invalid packet received. Size too small.");
+
+	// Check that remote can call the RPC on this node.
+	const Multiplayer::RPCConfig config = _get_rpc_config_by_id(p_node, p_rpc_method_id);
+	ERR_FAIL_COND(config.name == StringName());
+
+	bool can_call = _can_call_mode(p_node, config.rpc_mode, p_from);
+	ERR_FAIL_COND_MSG(!can_call, "RPC '" + String(config.name) + "' is not allowed on node " + p_node->get_path() + " from: " + itos(p_from) + ". Mode is " + itos((int)config.rpc_mode) + ", authority is " + itos(p_node->get_multiplayer_authority()) + ".");
+
+	int argc = 0;
+
+	const bool byte_only_or_no_args = p_packet[0] & BYTE_ONLY_OR_NO_ARGS_FLAG;
+	if (byte_only_or_no_args) {
+		if (p_offset < p_packet_len) {
+			// This packet contains only bytes.
+			argc = 1;
+		}
+	} else {
+		// Normal variant, takes the argument count from the packet.
+		ERR_FAIL_COND_MSG(p_offset >= p_packet_len, "Invalid packet received. Size too small.");
+		argc = p_packet[p_offset];
+		p_offset += 1;
+	}
+
+	Vector<Variant> args;
+	Vector<const Variant *> argp;
+	args.resize(argc);
+	argp.resize(argc);
+
+#ifdef DEBUG_ENABLED
+	_profile_node_data("in_rpc", p_node->get_instance_id());
+#endif
+
+	int out;
+	MultiplayerAPI::decode_and_decompress_variants(args, &p_packet[p_offset], p_packet_len - p_offset, out, byte_only_or_no_args, multiplayer->is_object_decoding_allowed());
+	for (int i = 0; i < argc; i++) {
+		argp.write[i] = &args[i];
+	}
+
+	Callable::CallError ce;
+
+	p_node->call(config.name, (const Variant **)argp.ptr(), argc, ce);
+	if (ce.error != Callable::CallError::CALL_OK) {
+		String error = Variant::get_call_error_text(p_node, config.name, (const Variant **)argp.ptr(), argc, ce);
+		error = "RPC - " + error;
+		ERR_PRINT(error);
+	}
+}
+
+void SceneRPCInterface::_send_rpc(Node *p_from, int p_to, uint16_t p_rpc_id, const Multiplayer::RPCConfig &p_config, const StringName &p_name, const Variant **p_arg, int p_argcount) {
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	ERR_FAIL_COND_MSG(peer.is_null(), "Attempt to call RPC without active multiplayer peer.");
+
+	ERR_FAIL_COND_MSG(peer->get_connection_status() == MultiplayerPeer::CONNECTION_CONNECTING, "Attempt to call RPC while multiplayer peer is not connected yet.");
+
+	ERR_FAIL_COND_MSG(peer->get_connection_status() == MultiplayerPeer::CONNECTION_DISCONNECTED, "Attempt to call RPC while multiplayer peer is disconnected.");
+
+	ERR_FAIL_COND_MSG(p_argcount > 255, "Too many arguments (>255).");
+
+	if (p_to != 0 && !multiplayer->get_connected_peers().has(ABS(p_to))) {
+		ERR_FAIL_COND_MSG(p_to == peer->get_unique_id(), "Attempt to call RPC on yourself! Peer unique ID: " + itos(peer->get_unique_id()) + ".");
+
+		ERR_FAIL_MSG("Attempt to call RPC with unknown peer ID: " + itos(p_to) + ".");
+	}
+
+	NodePath from_path = multiplayer->get_root_path().rel_path_to(p_from->get_path());
+	ERR_FAIL_COND_MSG(from_path.is_empty(), "Unable to send RPC. Relative path is empty. THIS IS LIKELY A BUG IN THE ENGINE!");
+
+	// See if all peers have cached path (if so, call can be fast).
+	int psc_id;
+	const bool has_all_peers = multiplayer->send_object_cache(p_from, from_path, p_to, psc_id);
+
+	// Create base packet, lots of hardcode because it must be tight.
+
+	int ofs = 0;
+
+#define MAKE_ROOM(m_amount)             \
+	if (packet_cache.size() < m_amount) \
+		packet_cache.resize(m_amount);
+
+	// Encode meta.
+	uint8_t command_type = MultiplayerAPI::NETWORK_COMMAND_REMOTE_CALL;
+	uint8_t node_id_compression = UINT8_MAX;
+	uint8_t name_id_compression = UINT8_MAX;
+	bool byte_only_or_no_args = false;
+
+	MAKE_ROOM(1);
+	// The meta is composed along the way, so just set 0 for now.
+	packet_cache.write[0] = 0;
+	ofs += 1;
+
+	// Encode Node ID.
+	if (has_all_peers) {
+		// Compress the node ID only if all the target peers already know it.
+		if (psc_id >= 0 && psc_id <= 255) {
+			// We can encode the id in 1 byte
+			node_id_compression = NETWORK_NODE_ID_COMPRESSION_8;
+			MAKE_ROOM(ofs + 1);
+			packet_cache.write[ofs] = static_cast<uint8_t>(psc_id);
+			ofs += 1;
+		} else if (psc_id >= 0 && psc_id <= 65535) {
+			// We can encode the id in 2 bytes
+			node_id_compression = NETWORK_NODE_ID_COMPRESSION_16;
+			MAKE_ROOM(ofs + 2);
+			encode_uint16(static_cast<uint16_t>(psc_id), &(packet_cache.write[ofs]));
+			ofs += 2;
+		} else {
+			// Too big, let's use 4 bytes.
+			node_id_compression = NETWORK_NODE_ID_COMPRESSION_32;
+			MAKE_ROOM(ofs + 4);
+			encode_uint32(psc_id, &(packet_cache.write[ofs]));
+			ofs += 4;
+		}
+	} else {
+		// The targets don't know the node yet, so we need to use 32 bits int.
+		node_id_compression = NETWORK_NODE_ID_COMPRESSION_32;
+		MAKE_ROOM(ofs + 4);
+		encode_uint32(psc_id, &(packet_cache.write[ofs]));
+		ofs += 4;
+	}
+
+	// Encode method ID
+	if (p_rpc_id <= UINT8_MAX) {
+		// The ID fits in 1 byte
+		name_id_compression = NETWORK_NAME_ID_COMPRESSION_8;
+		MAKE_ROOM(ofs + 1);
+		packet_cache.write[ofs] = static_cast<uint8_t>(p_rpc_id);
+		ofs += 1;
+	} else {
+		// The ID is larger, let's use 2 bytes
+		name_id_compression = NETWORK_NAME_ID_COMPRESSION_16;
+		MAKE_ROOM(ofs + 2);
+		encode_uint16(p_rpc_id, &(packet_cache.write[ofs]));
+		ofs += 2;
+	}
+
+	int len;
+	Error err = MultiplayerAPI::encode_and_compress_variants(p_arg, p_argcount, nullptr, len, &byte_only_or_no_args, multiplayer->is_object_decoding_allowed());
+	ERR_FAIL_COND_MSG(err != OK, "Unable to encode RPC arguments. THIS IS LIKELY A BUG IN THE ENGINE!");
+	if (byte_only_or_no_args) {
+		MAKE_ROOM(ofs + len);
+	} else {
+		MAKE_ROOM(ofs + 1 + len);
+		packet_cache.write[ofs] = p_argcount;
+		ofs += 1;
+	}
+	if (len) {
+		MultiplayerAPI::encode_and_compress_variants(p_arg, p_argcount, &packet_cache.write[ofs], len, &byte_only_or_no_args, multiplayer->is_object_decoding_allowed());
+		ofs += len;
+	}
+
+	ERR_FAIL_COND(command_type > 7);
+	ERR_FAIL_COND(node_id_compression > 3);
+	ERR_FAIL_COND(name_id_compression > 1);
+
+	// We can now set the meta
+	packet_cache.write[0] = command_type + (node_id_compression << NODE_ID_COMPRESSION_SHIFT) + (name_id_compression << NAME_ID_COMPRESSION_SHIFT) + (byte_only_or_no_args ? BYTE_ONLY_OR_NO_ARGS_FLAG : 0);
+
+#ifdef DEBUG_ENABLED
+	multiplayer->profile_bandwidth("out", ofs);
+#endif
+
+	// Take chance and set transfer mode, since all send methods will use it.
+	peer->set_transfer_channel(p_config.channel);
+	peer->set_transfer_mode(p_config.transfer_mode);
+
+	if (has_all_peers) {
+		// They all have verified paths, so send fast.
+		peer->set_target_peer(p_to); // To all of you.
+		peer->put_packet(packet_cache.ptr(), ofs); // A message with love.
+	} else {
+		// Unreachable because the node ID is never compressed if the peers doesn't know it.
+		CRASH_COND(node_id_compression != NETWORK_NODE_ID_COMPRESSION_32);
+
+		// Not all verified path, so send one by one.
+
+		// Append path at the end, since we will need it for some packets.
+		CharString pname = String(from_path).utf8();
+		int path_len = encode_cstring(pname.get_data(), nullptr);
+		MAKE_ROOM(ofs + path_len);
+		encode_cstring(pname.get_data(), &(packet_cache.write[ofs]));
+
+		for (const int &P : multiplayer->get_connected_peers()) {
+			if (p_to < 0 && P == -p_to) {
+				continue; // Continue, excluded.
+			}
+
+			if (p_to > 0 && P != p_to) {
+				continue; // Continue, not for this peer.
+			}
+
+			bool confirmed = multiplayer->is_cache_confirmed(from_path, P);
+
+			peer->set_target_peer(P); // To this one specifically.
+
+			if (confirmed) {
+				// This one confirmed path, so use id.
+				encode_uint32(psc_id, &(packet_cache.write[1]));
+				peer->put_packet(packet_cache.ptr(), ofs);
+			} else {
+				// This one did not confirm path yet, so use entire path (sorry!).
+				encode_uint32(0x80000000 | ofs, &(packet_cache.write[1])); // Offset to path and flag.
+				peer->put_packet(packet_cache.ptr(), ofs + path_len);
+			}
+		}
+	}
+}
+
+void SceneRPCInterface::rpcp(Object *p_obj, int p_peer_id, const StringName &p_method, const Variant **p_arg, int p_argcount) {
+	Ref<MultiplayerPeer> peer = multiplayer->get_multiplayer_peer();
+	ERR_FAIL_COND_MSG(!peer.is_valid(), "Trying to call an RPC while no multiplayer peer is active.");
+	Node *node = Object::cast_to<Node>(p_obj);
+	ERR_FAIL_COND(!node);
+	ERR_FAIL_COND_MSG(!node->is_inside_tree(), "Trying to call an RPC on a node which is not inside SceneTree.");
+	ERR_FAIL_COND_MSG(peer->get_connection_status() != MultiplayerPeer::CONNECTION_CONNECTED, "Trying to call an RPC via a multiplayer peer which is not connected.");
+
+	int node_id = peer->get_unique_id();
+	bool call_local_native = false;
+	bool call_local_script = false;
+	uint16_t rpc_id = UINT16_MAX;
+	const Multiplayer::RPCConfig config = _get_rpc_config(node, p_method, rpc_id);
+	ERR_FAIL_COND_MSG(config.name == StringName(),
+			vformat("Unable to get the RPC configuration for the function \"%s\" at path: \"%s\". This happens when the method is not marked for RPCs.", p_method, node->get_path()));
+	if (p_peer_id == 0 || p_peer_id == node_id || (p_peer_id < 0 && p_peer_id != -node_id)) {
+		if (rpc_id & (1 << 15)) {
+			call_local_native = config.call_local;
+		} else {
+			call_local_script = config.call_local;
+		}
+	}
+
+	if (p_peer_id != node_id) {
+#ifdef DEBUG_ENABLED
+		_profile_node_data("out_rpc", node->get_instance_id());
+#endif
+
+		_send_rpc(node, p_peer_id, rpc_id, config, p_method, p_arg, p_argcount);
+	}
+
+	if (call_local_native) {
+		Callable::CallError ce;
+
+		multiplayer->set_remote_sender_override(peer->get_unique_id());
+		node->call(p_method, p_arg, p_argcount, ce);
+		multiplayer->set_remote_sender_override(0);
+
+		if (ce.error != Callable::CallError::CALL_OK) {
+			String error = Variant::get_call_error_text(node, p_method, p_arg, p_argcount, ce);
+			error = "rpc() aborted in local call:  - " + error + ".";
+			ERR_PRINT(error);
+			return;
+		}
+	}
+
+	if (call_local_script) {
+		Callable::CallError ce;
+		ce.error = Callable::CallError::CALL_OK;
+
+		multiplayer->set_remote_sender_override(peer->get_unique_id());
+		node->get_script_instance()->call(p_method, p_arg, p_argcount, ce);
+		multiplayer->set_remote_sender_override(0);
+
+		if (ce.error != Callable::CallError::CALL_OK) {
+			String error = Variant::get_call_error_text(node, p_method, p_arg, p_argcount, ce);
+			error = "rpc() aborted in script local call:  - " + error + ".";
+			ERR_PRINT(error);
+			return;
+		}
+	}
+
+	ERR_FAIL_COND_MSG(p_peer_id == node_id && !config.call_local, "RPC '" + p_method + "' on yourself is not allowed by selected mode.");
+}
diff --git a/scene/multiplayer/scene_rpc_interface.h b/scene/multiplayer/scene_rpc_interface.h
new file mode 100644
index 0000000000..86e1d0d280
--- /dev/null
+++ b/scene/multiplayer/scene_rpc_interface.h
@@ -0,0 +1,91 @@
+/*************************************************************************/
+/*  scene_rpc_interface.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 SCENE_RPC_INTERFACE_H
+#define SCENE_RPC_INTERFACE_H
+
+#include "core/multiplayer/multiplayer.h"
+#include "core/multiplayer/multiplayer_api.h"
+
+class SceneRPCInterface : public MultiplayerRPCInterface {
+	GDCLASS(SceneRPCInterface, MultiplayerRPCInterface);
+
+private:
+	enum NetworkNodeIdCompression {
+		NETWORK_NODE_ID_COMPRESSION_8 = 0,
+		NETWORK_NODE_ID_COMPRESSION_16,
+		NETWORK_NODE_ID_COMPRESSION_32,
+	};
+
+	enum NetworkNameIdCompression {
+		NETWORK_NAME_ID_COMPRESSION_8 = 0,
+		NETWORK_NAME_ID_COMPRESSION_16,
+	};
+
+	// The RPC meta is composed by a single byte that contains (starting from the least significant bit):
+	// - `NetworkCommands` in the first four bits.
+	// - `NetworkNodeIdCompression` in the next 2 bits.
+	// - `NetworkNameIdCompression` in the next 1 bit.
+	// - `byte_only_or_no_args` in the next 1 bit.
+	enum {
+		NODE_ID_COMPRESSION_SHIFT = MultiplayerAPI::CMD_FLAG_0_SHIFT, // 2 bits for this.
+		NAME_ID_COMPRESSION_SHIFT = MultiplayerAPI::CMD_FLAG_2_SHIFT,
+		BYTE_ONLY_OR_NO_ARGS_SHIFT = MultiplayerAPI::CMD_FLAG_3_SHIFT,
+	};
+
+	enum {
+		NODE_ID_COMPRESSION_FLAG = (1 << NODE_ID_COMPRESSION_SHIFT) | (1 << (NODE_ID_COMPRESSION_SHIFT + 1)), // 2 bits for this.
+		NAME_ID_COMPRESSION_FLAG = (1 << NAME_ID_COMPRESSION_SHIFT),
+		BYTE_ONLY_OR_NO_ARGS_FLAG = (1 << BYTE_ONLY_OR_NO_ARGS_SHIFT),
+	};
+
+	MultiplayerAPI *multiplayer = nullptr;
+	Vector<uint8_t> packet_cache;
+
+protected:
+	static MultiplayerRPCInterface *_create(MultiplayerAPI *p_multiplayer);
+
+	_FORCE_INLINE_ void _profile_node_data(const String &p_what, ObjectID p_id);
+	void _process_rpc(Node *p_node, const uint16_t p_rpc_method_id, int p_from, const uint8_t *p_packet, int p_packet_len, int p_offset);
+
+	void _send_rpc(Node *p_from, int p_to, uint16_t p_rpc_id, const Multiplayer::RPCConfig &p_config, const StringName &p_name, const Variant **p_arg, int p_argcount);
+	Node *_process_get_node(int p_from, const uint8_t *p_packet, uint32_t p_node_target, int p_packet_len);
+
+public:
+	static void make_default();
+
+	virtual void rpcp(Object *p_obj, int p_peer_id, const StringName &p_method, const Variant **p_arg, int p_argcount) override;
+	virtual void process_rpc(int p_from, const uint8_t *p_packet, int p_packet_len) override;
+	virtual String get_rpc_md5(const Object *p_obj) const override;
+
+	SceneRPCInterface(MultiplayerAPI *p_multiplayer) { multiplayer = p_multiplayer; }
+};
+
+#endif // SCENE_RPC_INTERFACE_H
diff --git a/scene/register_scene_types.cpp b/scene/register_scene_types.cpp
index f19b018982..9ed83eb8c3 100644
--- a/scene/register_scene_types.cpp
+++ b/scene/register_scene_types.cpp
@@ -136,7 +136,9 @@
 #include "scene/main/window.h"
 #include "scene/multiplayer/multiplayer_spawner.h"
 #include "scene/multiplayer/multiplayer_synchronizer.h"
+#include "scene/multiplayer/scene_cache_interface.h"
 #include "scene/multiplayer/scene_replication_interface.h"
+#include "scene/multiplayer/scene_rpc_interface.h"
 #include "scene/resources/audio_stream_sample.h"
 #include "scene/resources/bit_map.h"
 #include "scene/resources/box_shape_3d.h"
@@ -1058,6 +1060,8 @@ void register_scene_types() {
 
 	SceneDebugger::initialize();
 	SceneReplicationInterface::make_default();
+	SceneRPCInterface::make_default();
+	SceneCacheInterface::make_default();
 
 	NativeExtensionManager::get_singleton()->initialize_extensions(NativeExtension::INITIALIZATION_LEVEL_SCENE);
 }