copilot/infinipaint
1
0
Fork 0
Code Issues Pull requests Projects Releases 1 Packages Wiki Activity Actions 1

Fixed compilation errors

Browse source
This commit is contained in:
Yousef Khadadeh 2025-12-11 22:41:53 +03:00
parent 5b5aef8369
commit cfd6f4b4e0
8 changed files with 34 additions and 25 deletions
Download patch file Download diff file Expand all files Collapse all files

4
include/Helpers/NetworkingObjects/NetObjGenericSerializedClass.hpp
View file

@ -12,7 +12,7 @@ namespace NetworkingObjects {
a(*o);
}
template <typename T> void default_serialize_read_constructor_func(NetObjManager*, const std::shared_ptr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) {
template <typename T> void default_serialize_read_constructor_func(const NetObjTemporaryPtr<T>& o, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) {
a(*o);
}
@ -32,7 +32,7 @@ namespace NetworkingObjects {
});
}
template <typename T> void generic_serialized_class_send_update_to_all(const NetworkingObjects::NetObjTemporaryPtr<T>& o) {
template <typename T> void generic_serialized_class_send_update_to_all(const NetObjTemporaryPtr<T>& o) {
o.send_update_to_all(RELIABLE_COMMAND_CHANNEL, default_serialize_write_func<T>);
}
}

16
include/Helpers/NetworkingObjects/NetObjManager.hpp
View file

@ -30,8 +30,8 @@ namespace NetworkingObjects {
auto it = objectData.find(id);
if(it != objectData.end())
throw std::runtime_error("[NetObjManager::read_create_message] Attempted to create an object with a used ID");
NetObjOwnerPtr<T> newPtr = emplace_raw_ptr(id, typeList->get_type_index_data<T>(isServer).allocatorFunc());
typeList->get_type_index_data<T>(isServer).readConstructorFunc(newPtr, a, clientReceivedFrom);
NetObjOwnerPtr<T> newPtr = emplace_raw_ptr(id, static_cast<T*>(typeList->get_type_index_data<T>(isServer).allocatorFunc()));
typeList->get_type_index_data<T>(isServer).readConstructorFunc(NetObjTemporaryPtr(newPtr).template cast<void>(), a, clientReceivedFrom);
return newPtr;
}
template <typename T> NetObjTemporaryPtr<T> read_get_obj_ref_from_message(cereal::PortableBinaryInputArchive& a) {
@ -39,11 +39,11 @@ namespace NetworkingObjects {
a(id);
auto it = objectData.find(id);
if(it == objectData.end())
return NetObjPtr<T>();
return NetObjPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p));
return NetObjTemporaryPtr<T>();
return NetObjTemporaryPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p));
}
template <typename T> NetObjOwnerPtr<T> make_obj() {
return emplace_raw_ptr<T>(NetObjID::random_gen(), typeList->get_type_index_data<T>(isServer).allocatorFunc());
return emplace_raw_ptr<T>(NetObjID::random_gen(), static_cast<T*>(typeList->get_type_index_data<T>(isServer).allocatorFunc()));
}
// Don't use this function unless you're sure that class T isn't a base class
template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct(Args&&... items) {
@ -56,7 +56,7 @@ namespace NetworkingObjects {
auto it = objectData.find(id);
if(it == objectData.end())
throw std::runtime_error("[NetObjManager::get_obj_from_id] ID doesn't exist");
return NetObjPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p));
return NetObjOwnerPtr<T>(this, id, static_cast<T*>(it->second.p));
}
private:
template <typename T> NetObjOwnerPtr<T> emplace_raw_ptr(NetObjID id, T* rawPtr) {
@ -121,8 +121,8 @@ namespace NetworkingObjects {
}
template <typename T> static void write_create_message(const NetObjTemporaryPtr<T>& ptr, cereal::PortableBinaryOutputArchive& a) {
a(ptr.get_obj_man()->id);
ptr.get_obj_man()->typeList->template get_type_index_data<T>(ptr.get_obj_man()->isServer).writeConstructorFunc(ptr, a);
a(ptr.get_net_id());
ptr.get_obj_man()->typeList->template get_type_index_data<T>(ptr.get_obj_man()->isServer).writeConstructorFunc(ptr.template cast<void>(), a);
}
template <typename T> friend class NetObjOwnerPtr;

19
include/Helpers/NetworkingObjects/NetObjOrderedList.hpp
View file

@ -68,7 +68,7 @@ namespace NetworkingObjects {
virtual uint32_t erase_by_ptr(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, const NetObjTemporaryPtr<T>& p) = 0;
virtual void write_constructor(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryOutputArchive& a) = 0;
virtual void read_update(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) = 0;
virtual void read_constructor(NetObjManager* objMan, const std::shared_ptr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) = 0;
virtual void read_constructor(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) = 0;
private:
template <typename S> friend void register_ordered_list_class(NetObjManagerTypeList& t);
static void write_constructor_func(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryOutputArchive& a) {
@ -144,13 +144,13 @@ namespace NetworkingObjects {
for(size_t i = 0; i < data.size(); i++)
data[i]->obj.write_create_message(a);
}
virtual void read_constructor(NetObjManager* objMan, const std::shared_ptr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c) override {
virtual void read_constructor(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>& c) override {
uint32_t constructedSize;
a(constructedSize);
data.clear();
idToDataMap.clear();
for(uint32_t i = 0; i < constructedSize; i++) {
data.emplace_back(std::make_shared<NetObjOrderedListObjectInfo<T>>(objMan->template read_create_message<T>(a, c), static_cast<uint32_t>(data.size())));
data.emplace_back(std::make_shared<NetObjOrderedListObjectInfo<T>>(l.get_obj_man()->template read_create_message<T>(a, c), static_cast<uint32_t>(data.size())));
idToDataMap.emplace(data.back()->obj.get_net_id(), data.back());
}
// Dont send the object data to all clients in the constructor, as the function that called read_create_message is also the one that will decide where to send the data of the constructed object
@ -239,15 +239,15 @@ namespace NetworkingObjects {
for(size_t i = 0; i < clientData.size(); i++)
clientData[i]->obj.write_create_message(a);
}
virtual void read_constructor(NetObjManager* objMan, const std::shared_ptr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) override {
virtual void read_constructor(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryInputArchive& a, const std::shared_ptr<NetServer::ClientData>&) override {
uint32_t constructedSize;
a(constructedSize);
clientData.clear();
serverData.clear();
clientIdToDataMap.clear();
for(uint32_t i = 0; i < constructedSize; i++) {
clientData.emplace_back(std::make_shared<NetObjOrderedListObjectInfo<T>>(objMan->template read_create_message<T>(a, nullptr), static_cast<uint32_t>(serverData.size())));
clientIdToDataMap.emplace_back(clientData.back()->obj.get_net_id(), serverData.back());
clientData.emplace_back(std::make_shared<NetObjOrderedListObjectInfo<T>>(l.get_obj_man()->template read_create_message<T>(a, nullptr), static_cast<uint32_t>(serverData.size())));
clientIdToDataMap.emplace(clientData.back()->obj.get_net_id(), clientData.back());
serverData.emplace_back(clientData.back()->obj.get_net_id());
}
}
@ -261,7 +261,7 @@ namespace NetworkingObjects {
a(newServerPos, newObjID);
serverData.insert(serverData.begin() + newServerPos, newObjID);
clientJustInsertedSyncIgnore.erase(newObjID);
sync();
sync(std::unordered_map<NetObjID, NetObjOrderedListObjectInfoPtr<T>>());
break;
}
case ObjPtrOrderedListCommand_StoC::INSERT_SINGLE_CONSTRUCT: {
@ -270,7 +270,10 @@ namespace NetworkingObjects {
auto objInfoToInsert = std::make_shared<NetObjOrderedListObjectInfo<T>>(l.get_obj_man()->template read_create_message<T>(a, nullptr), 0);
serverData.insert(serverData.begin() + newServerPos, objInfoToInsert->obj.get_net_id());
clientJustInsertedSyncIgnore.erase(objInfoToInsert->obj.get_net_id());
sync();
std::unordered_map<NetObjID, NetObjOrderedListObjectInfoPtr<T>> serverNewObjects;
serverNewObjects.emplace(objInfoToInsert->obj.get_net_id(), objInfoToInsert);
sync(serverNewObjects);
break;
}
case ObjPtrOrderedListCommand_StoC::ERASE_SINGLE: {

1
include/Helpers/NetworkingObjects/NetObjOwnerPtr.decl.hpp
View file

@ -30,6 +30,7 @@ namespace NetworkingObjects {
void write_create_message(cereal::PortableBinaryOutputArchive& a) const;
private:
friend class NetObjManager;
template <typename S> friend class NetObjWeakPtr;
template <typename S> friend class NetObjTemporaryPtr;
NetObjOwnerPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr);

13
include/Helpers/NetworkingObjects/NetObjOwnerPtr.impl.hpp
View file

@ -30,6 +30,7 @@ namespace NetworkingObjects {
rawPtr = other.rawPtr;
other.objMan = nullptr;
other.rawPtr = nullptr;
return *this;
}
template <typename T> NetObjOwnerPtr<T>::~NetObjOwnerPtr() {
@ -69,26 +70,26 @@ namespace NetworkingObjects {
}
template <typename T> void NetObjOwnerPtr<T>::send_client_update(const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) const {
NetObjManager::send_client_update(*this, channel, sendUpdateFunc);
NetObjManager::send_client_update(NetObjTemporaryPtr<T>(*this), channel, sendUpdateFunc);
}
template <typename T> void NetObjOwnerPtr<T>::send_server_update_to_all_clients(const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) const {
NetObjManager::send_server_update_to_all_clients(*this, channel, sendUpdateFunc);
NetObjManager::send_server_update_to_all_clients(NetObjTemporaryPtr<T>(*this), channel, sendUpdateFunc);
}
template <typename T> void NetObjOwnerPtr<T>::send_server_update_to_client(const std::shared_ptr<NetServer::ClientData>& clientToSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) const {
NetObjManager::send_server_update_to_client(*this, clientToSendTo, channel, sendUpdateFunc);
NetObjManager::send_server_update_to_client(NetObjTemporaryPtr<T>(*this), clientToSendTo, channel, sendUpdateFunc);
}
template <typename T> void NetObjOwnerPtr<T>::send_server_update_to_all_clients_except(const std::shared_ptr<NetServer::ClientData>& clientToNotSendTo, const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) const {
NetObjManager::send_server_update_to_all_clients_except(*this, clientToNotSendTo, channel, sendUpdateFunc);
NetObjManager::send_server_update_to_all_clients_except(NetObjTemporaryPtr<T>(*this), clientToNotSendTo, channel, sendUpdateFunc);
}
template <typename T> void NetObjOwnerPtr<T>::send_update_to_all(const std::string& channel, std::function<void(const NetObjTemporaryPtr<T>&, cereal::PortableBinaryOutputArchive&)> sendUpdateFunc) const {
NetObjManager::send_update_to_all(*this, channel, sendUpdateFunc);
NetObjManager::send_update_to_all(NetObjTemporaryPtr<T>(*this), channel, sendUpdateFunc);
}
template <typename T> void NetObjOwnerPtr<T>::write_create_message(cereal::PortableBinaryOutputArchive& a) const {
NetObjManager::write_create_message(*this, a);
NetObjManager::write_create_message(NetObjTemporaryPtr<T>(*this), a);
}
template <typename T> NetObjOwnerPtr<T>::NetObjOwnerPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr):

1
include/Helpers/NetworkingObjects/NetObjTemporaryPtr.decl.hpp
View file

@ -30,6 +30,7 @@ namespace NetworkingObjects {
private:
friend class NetObjManager;
template <typename S> friend class NetObjWeakPtr;
template <typename S> friend class NetObjTemporaryPtr;
NetObjTemporaryPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr);
NetObjManager* objMan;

2
include/Helpers/NetworkingObjects/NetObjTemporaryPtr.impl.hpp
View file

@ -31,7 +31,7 @@ namespace NetworkingObjects {
return *this;
}
template <typename T> template <typename S> NetObjTemporaryPtr<S> NetObjTemporaryPtr<T>::cast() const {
return NetObjPtr<S>(objMan, id, static_cast<S>(rawPtr));
return NetObjTemporaryPtr<S>(objMan, id, static_cast<S*>(rawPtr));
}
template <typename T> NetObjManager* NetObjTemporaryPtr<T>::get_obj_man() const {

3
include/Helpers/NetworkingObjects/NetObjWeakPtr.hpp
View file

@ -27,14 +27,17 @@ namespace NetworkingObjects {
NetObjWeakPtr& operator=(const NetObjOwnerPtr<T>& other) {
objMan = other.objMan;
id = other.id;
return *this;
}
NetObjWeakPtr& operator=(const NetObjTemporaryPtr<T>& other) {
objMan = other.objMan;
id = other.id;
return *this;
}
NetObjWeakPtr& operator=(const NetObjWeakPtr& other) {
objMan = other.objMan;
id = other.id;
return *this;
}
template <typename S> NetObjWeakPtr<S> cast() const {
return NetObjWeakPtr<S>(objMan, id);