HappyTanuki/Np_Term
1
0
Fork 0
Code Issues Pull Requests Actions Packages Projects Releases 5 Wiki Activity

모델 업로드 구조 완성

Browse Source
This commit is contained in:
HappyTanuki
2025-06-15 03:42:25 +09:00
parent 93fda88d75
commit 06a1e41dc8
13 changed files with 149 additions and 128 deletions
Download Patch File Download Diff File Expand all files Collapse all files

52
impl/socket/iocp.cpp
View File

@@ -40,21 +40,22 @@ void IOCP::destruct() {
#endif
}
void IOCP::registerTCPSocket(IOCPPASSINDATA* data) {
void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort(
(HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock.sock,
completionPort_, sock.sock, 0);
if (returnData == 0) completionPort_ = returnData;
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = data->socket;
recv_data->socket = std::make_shared<Socket>(sock);
recv_data->IOCPInstance = this;
DWORD recvbytes = 0, flags = 0;
int result = SOCKET_ERROR;
::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes, &flags,
&recv_data->overlapped, NULL);
result = ::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_data->overlapped, NULL);
if (result == SOCKET_ERROR) {
int err = ::WSAGetLastError();
if (err != WSA_IO_PENDING) {
@@ -94,12 +95,11 @@ void IOCP::registerUDPSocket(IOCPPASSINDATA* data, Address recv_addr) {
#endif
}
int IOCP::recv(IOCPPASSINDATA* data) { // 읽은 바이트수가 무조건 100임? 왜..?
SOCKET sock = data->socket->sock;
std::lock_guard lock(*GetRecvQueueMutex_(sock));
auto queue = GetRecvQueue_(sock);
int IOCP::recv(Socket& sock, std::vector<char>& data) {
std::lock_guard lock(*GetRecvQueueMutex_(sock.sock));
auto queue = GetRecvQueue_(sock.sock);
std::uint32_t left_data = data->wsabuf.len;
std::uint32_t left_data = data.size();
std::uint32_t copied = 0;
while (!queue->empty() && left_data != 0) {
@@ -110,7 +110,7 @@ int IOCP::recv(IOCPPASSINDATA* data) { // 읽은 바이트수가 무조건 100
std::uint32_t available = front.first.size() - offset;
std::uint32_t to_copy = (left_data < available) ? left_data : available;
::memcpy(data->wsabuf.buf + copied, front.first.data() + offset, to_copy);
::memcpy(data.data() + copied, front.first.data() + offset, to_copy);
copied += to_copy;
left_data -= to_copy;
offset += to_copy;
@@ -125,17 +125,21 @@ int IOCP::recv(IOCPPASSINDATA* data) { // 읽은 바이트수가 무조건 100
return copied;
}
int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA*>* data) {
auto lk = GetSendQueueMutex_(sock);
auto queue = GetSendQueue_(sock);
int IOCP::send(Socket& sock, std::vector<char>& data) {
auto lk = GetSendQueueMutex_(sock.sock);
auto queue = GetSendQueue_(sock.sock);
std::lock_guard lock(*lk);
for (auto& it : *data) {
it->event = IOCPEVENT::WRITE;
queue->push_back(it);
}
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(data.size());
packet->event = IOCPEVENT::WRITE;
packet->socket = std::make_shared<Network::Socket>(sock);
packet->IOCPInstance = this;
::memcpy(packet->wsabuf.buf, data.data(), data.size());
packet->wsabuf.len = data.size();
queue->push_back(packet);
IOCPThread_->enqueueJob(
[this, sock](utils::ThreadPool* th, std::uint8_t __) {
[this, sock = sock.sock](utils::ThreadPool* th, std::uint8_t __) {
packet_sender_(sock);
},
0);
@@ -143,8 +147,8 @@ int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA*>* data) {
}
int IOCP::GetRecvedBytes(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
auto queue = GetRecvQueue_(sock);
std::lock_guard lock(socket_mod_mutex_);
int bytes = 0;
for (auto it : *queue) {
@@ -175,6 +179,10 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
spdlog::debug("Disconnected. [{}]",
(std::string)(data->socket->remoteAddr));
delete data;
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
0);
return;
} else {
data->transferredbytes = cbTransfrred;
}

4
impl/utils/generate_id.cpp
View File

@@ -9,13 +9,15 @@ static struct EpochInitializer {
std::chrono::system_clock::time_point EPOCH;
} epochInitializer;
Snowflake GenerateID() {
Snowflake GenerateID(std::uint16_t instance) {
static std::mutex snowflakeGenerateMutex_;
std::lock_guard<std::mutex> lock(snowflakeGenerateMutex_);
std::size_t tid =
std::hash<std::thread::id>{}(std::this_thread::get_id());
instance = instance << 3;
tid += instance;
thread_local static int sequence = 0;
Snowflake id = {};

24
impl/vulkan_engine/asset/object/model.cpp
View File

@@ -18,35 +18,16 @@ void Append(std::vector<char>& buffer, const T& value) {
buffer.insert(buffer.end(), data, data + sizeof(T));
}
template <typename T>
void AppendVector(std::vector<char>& buffer, const std::vector<T>& vec) {
std::uint32_t size = static_cast<std::uint32_t>(vec.size());
Append(buffer, size);
buffer.insert(buffer.end(), reinterpret_cast<const char*>(vec.data()),
reinterpret_cast<const char*>(vec.data() + size));
}
template <typename T>
void Read(const std::vector<char>& buffer, size_t& offset, T& out) {
std::memcpy(&out, buffer.data() + offset, sizeof(T));
offset += sizeof(T);
}
template <typename T>
void ReadVector(const std::vector<char>& buffer, size_t& offset,
std::vector<T>& out) {
std::uint32_t size = 0;
Read(buffer, offset, size);
out.resize(size);
std::memcpy(out.data(), buffer.data() + offset, sizeof(T) * size);
offset += sizeof(T) * size;
}
std::vector<char> Model::Serialize() {
std::vector<char> buffer;
AppendVector(buffer, vertices);
AppendVector(buffer, indices);
Append(buffer, ID);
Append(buffer, position);
Append(buffer, linear_velocity);
@@ -72,8 +53,7 @@ std::vector<char> Model::Serialize() {
void Model::Deserialize(std::vector<char> data) {
size_t offset = 0;
ReadVector(data, offset, vertices);
ReadVector(data, offset, indices);
Read(data, offset, ID);
Read(data, offset, position);
Read(data, offset, linear_velocity);

47
impl/vulkan_engine/vulkan/engine.cpp
View File

@@ -171,38 +171,35 @@ void Engine::Update() {
}
void Engine::NetUpdate(std::shared_ptr<Network::Socket> sock) {
NetworkUpload(sock);
RefreshFromServer(sock);
ResponseToServerAndRefresh(sock);
}
void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
Packet::Header header;
header.opcode = Packet::Opcode::UPDATEMODEL;
header.body_length = 0;
std::vector<Network::IOCPPASSINDATA*> data;
Network::IOCPPASSINDATA* packet =
new Network::IOCPPASSINDATA(sizeof(Packet::Header));
packet->event = Network::IOCPEVENT::WRITE;
packet->socket = sock;
::memcpy(packet->wsabuf.buf, &header, sizeof(Packet::Header));
packet->wsabuf.len = sizeof(Packet::Header);
data.push_back(packet);
std::vector<char> data;
for (auto& it : models_) {
auto model = it.second.Serialize();
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(model.size());
packet->event = Network::IOCPEVENT::WRITE;
packet->socket = sock;
::memcpy(packet->wsabuf.buf, model.data(), model.size());
packet->wsabuf.len = model.size();
data.push_back(packet);
if (!it.second.networkReplicated) continue;
Packet::Header header;
header.opcode = Packet::Opcode::UPDATEMODEL;
std::vector<char> model = it.second.Serialize();
header.body_length = model.size();
std::vector<char> header_serialized = header.Serialize();
data.insert(data.end(), header_serialized.begin(), header_serialized.end());
data.insert(data.end(), model.begin(), model.end());
}
iocp_->send(sock->sock, &data);
iocp_->send(*sock, data);
}
void Engine::RefreshFromServer(std::shared_ptr<Network::Socket> sock) {
Network::IOCPPASSINDATA* recv_data = new Network::IOCPPASSINDATA(16 * 1024);
recv_data->socket = sock;
iocp_->recv(recv_data);
void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
while (iocp_->GetRecvedBytes(sock->sock) < 6);
std::vector<char> recv_data(6);
iocp_->recv(*sock, recv_data);
Packet::Header header;
header.Deserialize(recv_data);
recv_data.resize(header.body_length);
while (iocp_->GetRecvedBytes(sock->sock) < header.body_length);
iocp_->recv(*sock, recv_data);
}
} // namespace veng