mirror/godot
2
0
Fork 0
mirror of https://github.com/godotengine/godot.git synced 2024-12-27 11:24:59 +08:00
Code Issues Packages Projects Releases Wiki Activity
cedf4ad011
godot/modules/multiplayer/scene_cache_interface.cpp

294 lines
11 KiB
C++
Raw Normal View History

One Copyright Update to rule them all As many open source projects have started doing it, we're removing the current year from the copyright notice, so that we don't need to bump it every year. It seems like only the first year of publication is technically relevant for copyright notices, and even that seems to be something that many companies stopped listing altogether (in a version controlled codebase, the commits are a much better source of date of publication than a hardcoded copyright statement). We also now list Godot Engine contributors first as we're collectively the current maintainers of the project, and we clarify that the "exclusive" copyright of the co-founders covers the timespan before opensourcing (their further contributions are included as part of Godot Engine contributors). Also fixed "cf." Frenchism - it's meant as "refer to / see".
2023-01-05 20:25:55 +08:00
/**************************************************************************/
/* scene_cache_interface.cpp */
/**************************************************************************/
/* This file is part of: */
/* GODOT ENGINE */
/* https://godotengine.org */
/**************************************************************************/
/* Copyright (c) 2014-present Godot Engine contributors (see AUTHORS.md). */
/* Copyright (c) 2007-2014 Juan Linietsky, Ariel Manzur. */
/* */
/* 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. */
/**************************************************************************/
[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.
2022-02-04 23:24:16 +08:00
#include "scene_cache_interface.h"
Style: Harmonize header includes in modules This applies our existing style guide, and adds a new rule to that style guide for modular components such as platform ports and modules: Includes from the platform port or module ("local" includes) should be listed first in their own block using relative paths, before Godot's "core" includes which use "absolute" (project folder relative) paths, and finally thirdparty includes. Includes in `#ifdef`s come after their relevant section, i.e. the overall structure is: - Local includes * Conditional local includes - Core includes * Conditional core includes - Thirdparty includes * Conditional thirdparty includes
2023-06-13 22:56:21 +08:00
#include "scene_multiplayer.h"
[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.
2022-02-04 23:24:16 +08:00
#include "core/io/marshalls.h"
#include "scene/main/node.h"
#include "scene/main/window.h"
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
#include "scene/scene_string_names.h"
SceneCacheInterface::NodeCache &SceneCacheInterface::_track(Node *p_node) {
const ObjectID oid = p_node->get_instance_id();
NodeCache *nc = nodes_cache.getptr(oid);
if (!nc) {
nodes_cache[oid] = NodeCache();
p_node->connect(SceneStringNames::get_singleton()->tree_exited, callable_mp(this, &SceneCacheInterface::_remove_node_cache).bind(oid), Object::CONNECT_ONE_SHOT);
}
return nodes_cache[oid];
}
void SceneCacheInterface::_remove_node_cache(ObjectID p_oid) {
NodeCache *nc = nodes_cache.getptr(p_oid);
if (!nc) {
return;
}
for (KeyValue<int, int> &E : nc->recv_ids) {
PeerInfo *pinfo = peers_info.getptr(E.key);
ERR_CONTINUE(!pinfo);
pinfo->recv_nodes.erase(E.value);
}
for (KeyValue<int, bool> &E : nc->confirmed_peers) {
PeerInfo *pinfo = peers_info.getptr(E.key);
ERR_CONTINUE(!pinfo);
pinfo->sent_nodes.erase(p_oid);
}
nodes_cache.erase(p_oid);
}
[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.
2022-02-04 23:24:16 +08:00
void SceneCacheInterface::on_peer_change(int p_id, bool p_connected) {
if (p_connected) {
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
peers_info.insert(p_id, PeerInfo());
[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.
2022-02-04 23:24:16 +08:00
} else {
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
PeerInfo *pinfo = peers_info.getptr(p_id);
ERR_FAIL_NULL(pinfo); // Bug.
for (KeyValue<int, ObjectID> E : pinfo->recv_nodes) {
NodeCache *nc = nodes_cache.getptr(E.value);
ERR_CONTINUE(!nc);
nc->recv_ids.erase(E.key);
}
for (const ObjectID &oid : pinfo->sent_nodes) {
NodeCache *nc = nodes_cache.getptr(oid);
ERR_CONTINUE(!nc);
nc->confirmed_peers.erase(p_id);
[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.
2022-02-04 23:24:16 +08:00
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
peers_info.erase(p_id);
[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.
2022-02-04 23:24:16 +08:00
}
}
void SceneCacheInterface::process_simplify_path(int p_from, const uint8_t *p_packet, int p_packet_len) {
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
ERR_FAIL_COND(!peers_info.has(p_from)); // Bug.
ERR_FAIL_COND_MSG(p_packet_len < 38, "Invalid packet received. Size too small.");
[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.
2022-02-04 23:24:16 +08:00
Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 23:40:07 +08:00
ERR_FAIL_NULL(root_node);
[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.
2022-02-04 23:24:16 +08:00
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;
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
ERR_FAIL_COND_MSG(peers_info[p_from].recv_nodes.has(id), vformat("Duplicate remote cache ID %d for peer %d", id, p_from));
[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.
2022-02-04 23:24:16 +08:00
String paths;
paths.parse_utf8((const char *)(p_packet + ofs), p_packet_len - ofs);
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
const NodePath path = paths;
[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.
2022-02-04 23:24:16 +08:00
Node *node = root_node->get_node(path);
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 23:40:07 +08:00
ERR_FAIL_NULL(node);
[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.
2022-02-04 23:24:16 +08:00
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);
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
peers_info[p_from].recv_nodes.insert(id, node->get_instance_id());
NodeCache &cache = _track(node);
cache.recv_ids.insert(p_from, id);
[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.
2022-02-04 23:24:16 +08:00
// 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);
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-13 05:12:42 +08:00
packet.write[0] = SceneMultiplayer::NETWORK_COMMAND_CONFIRM_PATH;
[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.
2022-02-04 23:24:16 +08:00
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);
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-13 05:12:42 +08:00
multiplayer_peer->set_transfer_mode(MultiplayerPeer::TRANSFER_MODE_RELIABLE);
[MP] Let MultiplayerAPI handle packet relaying and peer signaling. MultiplayerPeer changes: - Adds is_server_relay_supported virtual method Informs the upper MultiplayerAPI layer if it can signal peers connected to the server to other clients, and perform packet relaying among them. - Adds get_packet_channel and get_packet_mode virtual methods Allows the MultiplayerAPI to retrieve the channel and transfer modes to use when relaying the last received packet. SceneMultiplayerPeer changes: - Implement peer signaling and packet relaying when the MultiplayerPeer advertise they are supported. ENet, WebRTC, WebSocket changes: - Removed custom code for relaying from WebSocket and ENet, and let it be handled by the upper layer. - Update WebRTC to split create_client, create_server, and create_mesh, with the latter behaving like the old initialize with "server_compatibility = false", and the first two supporting the upper layer relaying protocol.
2022-10-09 02:50:19 +08:00
multiplayer->send_command(p_from, packet.ptr(), packet.size());
[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.
2022-02-04 23:24:16 +08:00
}
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.");
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
Node *root_node = SceneTree::get_singleton()->get_root()->get_node(multiplayer->get_root_path());
ERR_FAIL_NULL(root_node);
[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.
2022-02-04 23:24:16 +08:00
const bool valid_rpc_checksum = p_packet[1];
String paths;
paths.parse_utf8((const char *)&p_packet[2], p_packet_len - 2);
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
const NodePath path = paths;
[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.
2022-02-04 23:24:16 +08:00
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);
}
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
Node *node = root_node->get_node(path);
ERR_FAIL_NULL(node);
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
NodeCache *cache = nodes_cache.getptr(node->get_instance_id());
ERR_FAIL_NULL_MSG(cache, "Invalid packet received. Tries to confirm a node which was not requested.");
[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.
2022-02-04 23:24:16 +08:00
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
bool *confirmed = cache->confirmed_peers.getptr(p_from);
ERR_FAIL_NULL_MSG(confirmed, "Invalid packet received. Tries to confirm a node which was not requested.");
*confirmed = true;
[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.
2022-02-04 23:24:16 +08:00
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
Error SceneCacheInterface::_send_confirm_path(Node *p_node, NodeCache &p_cache, const List<int> &p_peers) {
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
// Encode function name.
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
const CharString path = String(multiplayer->get_root_path().rel_path_to(p_node->get_path())).utf8();
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
const int path_len = encode_cstring(path.get_data(), nullptr);
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
// 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.
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
Vector<uint8_t> packet;
packet.resize(1 + 4 + path_len + methods_md5_len);
int ofs = 0;
[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.
2022-02-04 23:24:16 +08:00
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-13 05:12:42 +08:00
packet.write[ofs] = SceneMultiplayer::NETWORK_COMMAND_SIMPLIFY_PATH;
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
ofs += 1;
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
ofs += encode_cstring(methods_md5.utf8().get_data(), &packet.write[ofs]);
[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.
2022-02-04 23:24:16 +08:00
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
ofs += encode_uint32(p_cache.cache_id, &packet.write[ofs]);
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
ofs += encode_cstring(path.get_data(), &packet.write[ofs]);
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
Ref<MultiplayerPeer> multiplayer_peer = multiplayer->get_multiplayer_peer();
ERR_FAIL_COND_V(multiplayer_peer.is_null(), ERR_BUG);
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
Error err = OK;
for (int peer_id : p_peers) {
multiplayer_peer->set_transfer_channel(0);
[Net] Modularize multiplayer, expose MultiplayerAPI to extensions. - RPC configurations are now dictionaries. - Script.get_rpc_methods renamed to Script.get_rpc_config. - Node.rpc[_id] and Callable.rpc now return an Error. - Refactor MultiplayerAPI to allow extension. - New MultiplayerAPI.rpc method with Array argument (for scripts). - Move the default MultiplayerAPI implementation to a module.
2022-07-13 05:12:42 +08:00
multiplayer_peer->set_transfer_mode(MultiplayerPeer::TRANSFER_MODE_RELIABLE);
[MP] Let MultiplayerAPI handle packet relaying and peer signaling. MultiplayerPeer changes: - Adds is_server_relay_supported virtual method Informs the upper MultiplayerAPI layer if it can signal peers connected to the server to other clients, and perform packet relaying among them. - Adds get_packet_channel and get_packet_mode virtual methods Allows the MultiplayerAPI to retrieve the channel and transfer modes to use when relaying the last received packet. SceneMultiplayerPeer changes: - Implement peer signaling and packet relaying when the MultiplayerPeer advertise they are supported. ENet, WebRTC, WebSocket changes: - Removed custom code for relaying from WebSocket and ENet, and let it be handled by the upper layer. - Update WebRTC to split create_client, create_server, and create_mesh, with the latter behaving like the old initialize with "server_compatibility = false", and the first two supporting the upper layer relaying protocol.
2022-10-09 02:50:19 +08:00
err = multiplayer->send_command(peer_id, packet.ptr(), packet.size());
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
ERR_FAIL_COND_V(err != OK, err);
// Insert into confirmed, but as false since it was not confirmed.
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
p_cache.confirmed_peers.insert(peer_id, false);
ERR_CONTINUE(!peers_info.has(peer_id));
peers_info[peer_id].sent_nodes.insert(p_node->get_instance_id());
[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.
2022-02-04 23:24:16 +08:00
}
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
return err;
[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.
2022-02-04 23:24:16 +08:00
}
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
bool SceneCacheInterface::is_cache_confirmed(Node *p_node, int p_peer) {
ERR_FAIL_NULL_V(p_node, false);
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
const ObjectID oid = p_node->get_instance_id();
NodeCache *cache = nodes_cache.getptr(oid);
bool *confirmed = cache ? cache->confirmed_peers.getptr(p_peer) : nullptr;
return confirmed && *confirmed;
[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.
2022-02-04 23:24:16 +08:00
}
Add peer visibility to MultiplayerSynchronizer. MultiplayerSynchronizers can now be configured to limit their visibility to a subset of the connected peers, if the synchronized node was spawned by a MultiplayerSpawner (either automatically or via custom spawn) the given node will also be despawned remotely. The replication system doesn't have the logic to handle subspawn directly, but it is possible to handle them appropriately by manually updating the visibility of the parent before changing the one of the nested spawns via the "update_visibility" function. The visibility of each MultiplayerSynchronizer can be controlled by adding or remove filters via "[add|remove]_visibility_filter(callable)". To further optimize the network code, visibility filters can be configured to be automatically updated during idle or physics frame, or set to always require manual update (via the "update_visibility" function).
2022-07-10 02:45:30 +08:00
int SceneCacheInterface::make_object_cache(Object *p_obj) {
[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.
2022-02-04 23:24:16 +08:00
Node *node = Object::cast_to<Node>(p_obj);
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 23:40:07 +08:00
ERR_FAIL_NULL_V(node, -1);
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
NodeCache &cache = _track(node);
if (cache.cache_id == 0) {
cache.cache_id = last_send_cache_id++;
[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.
2022-02-04 23:24:16 +08:00
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
return cache.cache_id;
Add peer visibility to MultiplayerSynchronizer. MultiplayerSynchronizers can now be configured to limit their visibility to a subset of the connected peers, if the synchronized node was spawned by a MultiplayerSpawner (either automatically or via custom spawn) the given node will also be despawned remotely. The replication system doesn't have the logic to handle subspawn directly, but it is possible to handle them appropriately by manually updating the visibility of the parent before changing the one of the nested spawns via the "update_visibility" function. The visibility of each MultiplayerSynchronizer can be controlled by adding or remove filters via "[add|remove]_visibility_filter(callable)". To further optimize the network code, visibility filters can be configured to be automatically updated during idle or physics frame, or set to always require manual update (via the "update_visibility" function).
2022-07-10 02:45:30 +08:00
}
bool SceneCacheInterface::send_object_cache(Object *p_obj, int p_peer_id, int &r_id) {
Node *node = Object::cast_to<Node>(p_obj);
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 23:40:07 +08:00
ERR_FAIL_NULL_V(node, false);
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
// See if the path is cached.
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
NodeCache &cache = _track(node);
if (cache.cache_id == 0) {
cache.cache_id = last_send_cache_id++;
[MP] Optimize multiplayer NodePath caching Only use paths during network transfer. Use ObjectID instead of NodePaths for storing the Node <-> NetID relations locally.
2023-09-27 02:27:53 +08:00
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
r_id = cache.cache_id;
[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.
2022-02-04 23:24:16 +08:00
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
bool has_all_peers = true;
List<int> peers_to_add; // If one is missing, take note to add it.
if (p_peer_id > 0) {
// Fast single peer check.
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
ERR_FAIL_COND_V_MSG(!peers_info.has(p_peer_id), false, "Peer doesn't exist: " + itos(p_peer_id));
bool *confirmed = cache.confirmed_peers.getptr(p_peer_id);
if (!confirmed) {
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
peers_to_add.push_back(p_peer_id); // Need to also be notified.
has_all_peers = false;
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
} else if (!(*confirmed)) {
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
has_all_peers = false;
}
} else {
// Long and painful.
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
for (KeyValue<int, PeerInfo> &E : peers_info) {
if (p_peer_id < 0 && E.key == -p_peer_id) {
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
continue; // Continue, excluded.
}
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
bool *confirmed = cache.confirmed_peers.getptr(E.key);
if (!confirmed) {
peers_to_add.push_back(E.key); // Need to also be notified.
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
has_all_peers = false;
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
} else if (!(*confirmed)) {
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
has_all_peers = false;
}
}
}
if (peers_to_add.size()) {
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
_send_confirm_path(node, cache, peers_to_add);
[Net] Optimize object cache notification send for single peer. It used to always cycle all the peers when checking which one needed to be notified, now it only does that when the target is multiple (i.e. broadcast or exclusion).
2022-02-22 02:45:18 +08:00
}
return has_all_peers;
[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.
2022-02-04 23:24:16 +08:00
}
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());
[Modules] Replace `ERR_FAIL_COND` with `ERR_FAIL_NULL` where applicable
2023-09-09 23:40:07 +08:00
ERR_FAIL_NULL_V(root_node, nullptr);
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
PeerInfo *pinfo = peers_info.getptr(p_from);
ERR_FAIL_NULL_V(pinfo, nullptr);
[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.
2022-02-04 23:24:16 +08:00
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
const ObjectID *oid = pinfo->recv_nodes.getptr(p_cache_id);
ERR_FAIL_NULL_V_MSG(oid, nullptr, vformat("ID %d not found in cache of peer %d.", p_cache_id, p_from));
Node *node = Object::cast_to<Node>(ObjectDB::get_instance(*oid));
ERR_FAIL_NULL_V_MSG(node, nullptr, vformat("Failed to get cached node from peer %d with cache ID %d.", p_from, p_cache_id));
[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.
2022-02-04 23:24:16 +08:00
return node;
}
void SceneCacheInterface::clear() {
[MP] Handle cleanup of "scene cache" nodes Make sure we delete the relevant ObjectID from the cache when the nodes are removed from tree.
2023-12-10 21:40:18 +08:00
for (KeyValue<ObjectID, NodeCache> &E : nodes_cache) {
Object *obj = ObjectDB::get_instance(E.key);
ERR_CONTINUE(!obj);
obj->disconnect(SceneStringNames::get_singleton()->tree_exited, callable_mp(this, &SceneCacheInterface::_remove_node_cache));
}
peers_info.clear();
nodes_cache.clear();
[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.
2022-02-04 23:24:16 +08:00
last_send_cache_id = 1;
}
Reference in New Issue Copy Permalink