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

Now uses two interfaces so it can be overridden in the future, and
core no longer depends on Node.

The interfaces are implements in scene/multiplayer.
Replaces root_node with root_path.
Remove all Node references from 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);
 }