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); 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); 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>); 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); auto it = objectData.find(id);
if(it != objectData.end()) if(it != objectData.end())
throw std::runtime_error("[NetObjManager::read_create_message] Attempted to create an object with a used ID"); 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()); 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(newPtr, a, clientReceivedFrom); typeList->get_type_index_data<T>(isServer).readConstructorFunc(NetObjTemporaryPtr(newPtr).template cast<void>(), a, clientReceivedFrom);
return newPtr; return newPtr;
} }
template <typename T> NetObjTemporaryPtr<T> read_get_obj_ref_from_message(cereal::PortableBinaryInputArchive& a) { template <typename T> NetObjTemporaryPtr<T> read_get_obj_ref_from_message(cereal::PortableBinaryInputArchive& a) {
@ -39,11 +39,11 @@ namespace NetworkingObjects {
a(id); a(id);
auto it = objectData.find(id); auto it = objectData.find(id);
if(it == objectData.end()) if(it == objectData.end())
return NetObjPtr<T>(); return NetObjTemporaryPtr<T>();
return NetObjPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p)); return NetObjTemporaryPtr<T>(this, id, std::static_pointer_cast<T>(it->second.p));
} }
template <typename T> NetObjOwnerPtr<T> make_obj() { 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 // 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) { template <typename T, typename... Args> NetObjOwnerPtr<T> make_obj_direct(Args&&... items) {
@ -56,7 +56,7 @@ namespace NetworkingObjects {
auto it = objectData.find(id); auto it = objectData.find(id);
if(it == objectData.end()) if(it == objectData.end())
throw std::runtime_error("[NetObjManager::get_obj_from_id] ID doesn't exist"); 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: private:
template <typename T> NetObjOwnerPtr<T> emplace_raw_ptr(NetObjID id, T* rawPtr) { 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) { template <typename T> static void write_create_message(const NetObjTemporaryPtr<T>& ptr, cereal::PortableBinaryOutputArchive& a) {
a(ptr.get_obj_man()->id); a(ptr.get_net_id());
ptr.get_obj_man()->typeList->template get_type_index_data<T>(ptr.get_obj_man()->isServer).writeConstructorFunc(ptr, a); 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; 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 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 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_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: private:
template <typename S> friend void register_ordered_list_class(NetObjManagerTypeList& t); template <typename S> friend void register_ordered_list_class(NetObjManagerTypeList& t);
static void write_constructor_func(const NetObjTemporaryPtr<NetObjOrderedList<T>>& l, cereal::PortableBinaryOutputArchive& a) { 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++) for(size_t i = 0; i < data.size(); i++)
data[i]->obj.write_create_message(a); 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; uint32_t constructedSize;
a(constructedSize); a(constructedSize);
data.clear(); data.clear();
idToDataMap.clear(); idToDataMap.clear();
for(uint32_t i = 0; i < constructedSize; i++) { 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()); 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 // 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++) for(size_t i = 0; i < clientData.size(); i++)
clientData[i]->obj.write_create_message(a); 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; uint32_t constructedSize;
a(constructedSize); a(constructedSize);
clientData.clear(); clientData.clear();
serverData.clear(); serverData.clear();
clientIdToDataMap.clear(); clientIdToDataMap.clear();
for(uint32_t i = 0; i < constructedSize; i++) { 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()))); 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_back(clientData.back()->obj.get_net_id(), serverData.back()); clientIdToDataMap.emplace(clientData.back()->obj.get_net_id(), clientData.back());
serverData.emplace_back(clientData.back()->obj.get_net_id()); serverData.emplace_back(clientData.back()->obj.get_net_id());
} }
} }
@ -261,7 +261,7 @@ namespace NetworkingObjects {
a(newServerPos, newObjID); a(newServerPos, newObjID);
serverData.insert(serverData.begin() + newServerPos, newObjID); serverData.insert(serverData.begin() + newServerPos, newObjID);
clientJustInsertedSyncIgnore.erase(newObjID); clientJustInsertedSyncIgnore.erase(newObjID);
sync(); sync(std::unordered_map<NetObjID, NetObjOrderedListObjectInfoPtr<T>>());
break; break;
} }
case ObjPtrOrderedListCommand_StoC::INSERT_SINGLE_CONSTRUCT: { 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); 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()); serverData.insert(serverData.begin() + newServerPos, objInfoToInsert->obj.get_net_id());
clientJustInsertedSyncIgnore.erase(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; break;
} }
case ObjPtrOrderedListCommand_StoC::ERASE_SINGLE: { 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; void write_create_message(cereal::PortableBinaryOutputArchive& a) const;
private: private:
friend class NetObjManager; friend class NetObjManager;
template <typename S> friend class NetObjWeakPtr;
template <typename S> friend class NetObjTemporaryPtr; template <typename S> friend class NetObjTemporaryPtr;
NetObjOwnerPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr); 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; rawPtr = other.rawPtr;
other.objMan = nullptr; other.objMan = nullptr;
other.rawPtr = nullptr; other.rawPtr = nullptr;
return *this;
} }
template <typename T> NetObjOwnerPtr<T>::~NetObjOwnerPtr() { 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 { 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 { 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 { 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 { 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 { 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 { 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): 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: private:
friend class NetObjManager; friend class NetObjManager;
template <typename S> friend class NetObjWeakPtr; template <typename S> friend class NetObjWeakPtr;
template <typename S> friend class NetObjTemporaryPtr;
NetObjTemporaryPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr); NetObjTemporaryPtr(NetObjManager* initObjMan, NetObjID initID, T* initRawPtr);
NetObjManager* objMan; NetObjManager* objMan;

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

@ -31,7 +31,7 @@ namespace NetworkingObjects {
return *this; return *this;
} }
template <typename T> template <typename S> NetObjTemporaryPtr<S> NetObjTemporaryPtr<T>::cast() const { 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 { 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) { NetObjWeakPtr& operator=(const NetObjOwnerPtr<T>& other) {
objMan = other.objMan; objMan = other.objMan;
id = other.id; id = other.id;
return *this;
} }
NetObjWeakPtr& operator=(const NetObjTemporaryPtr<T>& other) { NetObjWeakPtr& operator=(const NetObjTemporaryPtr<T>& other) {
objMan = other.objMan; objMan = other.objMan;
id = other.id; id = other.id;
return *this;
} }
NetObjWeakPtr& operator=(const NetObjWeakPtr& other) { NetObjWeakPtr& operator=(const NetObjWeakPtr& other) {
objMan = other.objMan; objMan = other.objMan;
id = other.id; id = other.id;
return *this;
} }
template <typename S> NetObjWeakPtr<S> cast() const { template <typename S> NetObjWeakPtr<S> cast() const {
return NetObjWeakPtr<S>(objMan, id); return NetObjWeakPtr<S>(objMan, id);