godotengine/godot
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity
d6d87b6ca4
godot/modules/multiplayer/scene_cache_interface.cpp

256 lines
9.5 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 12:25:55 +00: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 15:24:16 +00:00
#include "scene_cache_interface.h"
#include "core/io/marshalls.h"
#include "scene/main/node.h"
#include "scene/main/window.h"
[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-12 21:12:42 +00: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 15:24:16 +00:00
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.
Add a new HashMap implementation Adds a new, cleaned up, HashMap implementation. * Uses Robin Hood Hashing (https://en.wikipedia.org/wiki/Hash_table#Robin_Hood_hashing). * Keeps elements in a double linked list for simpler, ordered, iteration. * Allows keeping iterators for later use in removal (Unlike Map<>, it does not do much for performance vs keeping the key, but helps replace old code). * Uses a more modern C++ iterator API, deprecates the old one. * Supports custom allocator (in case there is a wish to use a paged one). This class aims to unify all the associative template usage and replace it by this one: * Map<> (whereas key order does not matter, which is 99% of cases) * HashMap<> * OrderedHashMap<> * OAHashMap<>
2022-05-08 08:09:19 +00:00
for (const KeyValue<NodePath, PathSentCache> &E : path_send_cache) {
PathSentCache *psc = path_send_cache.getptr(E.key);
[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 15:24:16 +00:00
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);
[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-12 21:12:42 +00: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 15:24:16 +00: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-12 21:12:42 +00: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-08 18:50:19 +00: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 15:24:16 +00: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.");
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.");
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
HashMap<int, bool>::Iterator E = psc->confirmed_peers.find(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 15:24:16 +00:00
ERR_FAIL_COND_MSG(!E, "Invalid packet received. Source peer was not found in cache for the given path.");
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
E->value = 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 15:24:16 +00: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-21 18:45:18 +00:00
Error SceneCacheInterface::_send_confirm_path(Node *p_node, NodePath p_path, PathSentCache *psc, const List<int> &p_peers) {
// Encode function name.
const CharString path = String(p_path).utf8();
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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-12 21:12:42 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-21 18:45:18 +00:00
ofs += encode_uint32(psc->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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00: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-21 18:45:18 +00: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-12 21:12:42 +00: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-08 18:50:19 +00: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-21 18:45:18 +00:00
ERR_FAIL_COND_V(err != OK, err);
// Insert into confirmed, but as false since it was not confirmed.
psc->confirmed_peers.insert(peer_id, false);
[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 15:24:16 +00: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-21 18:45:18 +00: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 15:24:16 +00:00
}
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);
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
HashMap<int, bool>::ConstIterator F = psc->confirmed_peers.find(p_peer);
[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 15:24:16 +00:00
ERR_FAIL_COND_V(!F, false); // Should never happen.
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
return F->value;
[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 15:24:16 +00: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-09 18:45:30 +00: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 15:24:16 +00:00
Node *node = Object::cast_to<Node>(p_obj);
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-09 18:45:30 +00:00
ERR_FAIL_COND_V(!node, -1);
NodePath for_path = multiplayer->get_root_path().rel_path_to(node->get_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 15:24:16 +00:00
// See if the path is cached.
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-09 18:45:30 +00:00
PathSentCache *psc = path_send_cache.getptr(for_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 15:24:16 +00:00
if (!psc) {
// Path is not cached, create.
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-09 18:45:30 +00:00
path_send_cache[for_path] = PathSentCache();
psc = path_send_cache.getptr(for_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 15:24:16 +00:00
psc->id = last_send_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-09 18:45:30 +00:00
return psc->id;
}
bool SceneCacheInterface::send_object_cache(Object *p_obj, int p_peer_id, int &r_id) {
Node *node = Object::cast_to<Node>(p_obj);
ERR_FAIL_COND_V(!node, false);
r_id = make_object_cache(p_obj);
ERR_FAIL_COND_V(r_id < 0, false);
NodePath for_path = multiplayer->get_root_path().rel_path_to(node->get_path());
PathSentCache *psc = path_send_cache.getptr(for_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 15:24:16 +00: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-21 18:45:18 +00: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.
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
HashMap<int, bool>::Iterator F = psc->confirmed_peers.find(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-21 18:45:18 +00:00
if (!F) {
peers_to_add.push_back(p_peer_id); // Need to also be notified.
has_all_peers = false;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
} else if (!F->value) {
[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-21 18:45:18 +00:00
has_all_peers = false;
}
} else {
// Long and painful.
Use range iterators for RBSet in most cases
2022-05-18 23:43:40 +00:00
for (const int &E : multiplayer->get_connected_peers()) {
if (p_peer_id < 0 && E == -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-21 18:45:18 +00:00
continue; // Continue, excluded.
}
Use range iterators for RBSet in most cases
2022-05-18 23:43:40 +00:00
HashMap<int, bool>::Iterator F = psc->confirmed_peers.find(E);
[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-21 18:45:18 +00:00
if (!F) {
Use range iterators for RBSet in most cases
2022-05-18 23:43:40 +00:00
peers_to_add.push_back(E); // 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-21 18:45:18 +00:00
has_all_peers = false;
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
} else if (!F->value) {
[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-21 18:45:18 +00:00
has_all_peers = false;
}
}
}
if (peers_to_add.size()) {
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-09 18:45:30 +00:00
_send_confirm_path(node, for_path, psc, 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-21 18:45:18 +00: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 15:24:16 +00: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());
ERR_FAIL_COND_V(!root_node, nullptr);
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
HashMap<int, PathGetCache>::Iterator E = path_get_cache.find(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 15:24:16 +00:00
ERR_FAIL_COND_V_MSG(!E, nullptr, vformat("No cache found for peer %d.", p_from));
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
HashMap<int, PathGetCache::NodeInfo>::Iterator F = E->value.nodes.find(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 15:24:16 +00:00
ERR_FAIL_COND_V_MSG(!F, nullptr, vformat("ID %d not found in cache of peer %d.", p_cache_id, p_from));
Replace most uses of Map by HashMap * Map is unnecessary and inefficient in almost every case. * Replaced by the new HashMap. * Renamed Map to RBMap and Set to RBSet for cases that still make sense (order matters) but use is discouraged. There were very few cases where replacing by HashMap was undesired because keeping the key order was intended. I tried to keep those (as RBMap) as much as possible, but might have missed some. Review appreciated!
2022-05-13 13:04:37 +00:00
PathGetCache::NodeInfo *ni = &F->value;
[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 15:24:16 +00:00
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;
}
Reference in New Issue Copy Permalink