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-19 02:42:49 +09:00
parent 1b79d946c3
commit fc8217a608
25 changed files with 584 additions and 574 deletions
Download Patch File Download Diff File Expand all files Collapse all files

53
impl/socket/address.cpp
View File

@@ -4,50 +4,6 @@
namespace Network {
//void Address::set(int type, gsl::czstring presentationAddr,
// std::uint16_t port) {
// zeroFill();
// setType(type);
//
// if (type == AF_INET) {
// ::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
// addr_in.sin_port = htons(port);
// } else if (type == AF_INET6) {
// ::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
// addr_in6.sin6_port = htons(port);
// }
//
// BIO_ADDRINFO* res;
// if (!BIO_lookup_ex(presentationAddr, std::to_string(port).c_str(),
// BIO_LOOKUP_CLIENT, type, SOCK_DGRAM, 0, &res)) {
// ::BIO_ADDRINFO_free(res);
// throw std::runtime_error("can't resolve address");
// }
//
// int sock = -1;
// for (const BIO_ADDRINFO* ai = res; ai != nullptr;
// ai = ::BIO_ADDRINFO_next(ai)) {
// sock = ::BIO_socket(BIO_ADDRINFO_family(ai), type, 0, 0);
// if (sock == -1)
// continue;
// else {
// auto bio_addr = ::BIO_ADDRINFO_address(ai);
// BIO_ADDR_rawaddress(bio_addr, &addr, (unsigned long long*)&length);
// bio_addr_info = ::BIO_ADDR_dup(bio_addr);
//
// break;
// }
// }
//
// if (sock != -1)
// ::close(sock);
//
// ::BIO_ADDRINFO_free(res);
//
// addr_in.sin_family = type;
// addr_in.sin_port = htons(port);
//}
Address::Address() { zeroFill(); }
Address::Address(int type, gsl::czstring presentationAddr, std::uint16_t port) {
@@ -58,19 +14,18 @@ void Address::zeroFill() { memset(&addr_in6, 0, sizeof(addr_in6)); }
void Address::set(int type, gsl::czstring presentationAddr,
std::uint16_t port) {
zeroFill();
setType(type);
if (type == AF_INET) {
addr_in.sin_family = AF_INET;
::inet_pton(AF_INET, presentationAddr, &addr_in.sin_addr);
addr_in.sin_port = htons(port);
length = sizeof(sockaddr_in);
} else if (type == AF_INET6) {
addr_in6.sin6_family = AF_INET6;
::inet_pton(AF_INET6, presentationAddr, &addr_in6.sin6_addr);
addr_in6.sin6_port = htons(port);
length = sizeof(sockaddr_in6);
}
family = type;
}
void Address::setType(int type) {
@@ -87,12 +42,12 @@ Address::operator std::string() {
if (!port) return std::string();
if (length == sizeof(addr_in)) {
if (family == AF_INET) {
char addrStr[INET_ADDRSTRLEN];
::inet_ntop(AF_INET, &addr_in.sin_addr, addrStr, sizeof(addrStr));
return std::format("{}:{}", addrStr, port.value());
} else if (length == sizeof(addr_in6)) {
} else if (family == AF_INET6) {
char addrStr[INET6_ADDRSTRLEN];
::inet_ntop(AF_INET6, &addr_in6.sin6_addr, addrStr, sizeof(addrStr));

211
impl/socket/iocp.cpp
View File

@@ -4,7 +4,7 @@
namespace Network {
IOCP::IOCP() {
IOCP::IOCP() : IOCPThread_(nullptr), proto_(SessionProtocol::TCP) {
gen_ = std::mt19937(rd_());
jitterDist_ = std::uniform_int_distribution<int>(-10, 10);
}
@@ -40,22 +40,86 @@ void IOCP::destruct() {
#endif
}
void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
void IOCP::registerSocket(std::shared_ptr<Socket> sock) {
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock.sock,
completionPort_, sock.sock, 0);
HANDLE returnData = ::CreateIoCompletionPort((HANDLE)sock->sock,
completionPort_, sock->sock, 0);
if (returnData == 0) completionPort_ = returnData;
#endif
}
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = std::make_shared<Socket>(sock);
recv_data->IOCPInstance = this;
DWORD recvbytes = 0, flags = 0;
std::future<std::vector<char>> IOCP::recvFull(std::shared_ptr<Socket> sock,
std::uint32_t bufsize) {
auto promise = std::make_shared<std::promise<std::vector<char>>>();
auto future = promise->get_future();
auto buffer = std::make_shared<std::vector<char>>();
buffer->reserve(bufsize);
std::function<void(std::uint32_t)> recvChunk;
recvChunk = [=](std::uint32_t remaining) mutable {
this->recv(sock, remaining,
[=](utils::ThreadPool* th, IOCPPASSINDATA* data) {
buffer->insert(buffer->end(), data->wsabuf.buf,
data->wsabuf.buf + data->transferredbytes);
std::uint32_t still_left =
bufsize - static_cast<std::uint32_t>(buffer->size());
if (still_left > 0) {
recvChunk(still_left);
} else {
promise->set_value(std::move(*buffer));
}
return std::list<char>();
});
};
recvChunk(bufsize);
return future;
}
std::list<char> DEFAULT_RECVALL_CALLBACK(utils::ThreadPool* th,
IOCPPASSINDATA* data) {
std::list<char> return_value;
return_value.insert(return_value.end(), data->wsabuf.buf,
data->wsabuf.buf + data->transferredbytes);
if (data->transferredbytes < data->wsabuf.len) {
auto future = data->IOCPInstance->recv(
data->socket, data->wsabuf.len - data->transferredbytes,
DEFAULT_RECVALL_CALLBACK);
auto result = future.get();
return_value.insert(return_value.end(), result.begin(), result.end());
}
return return_value;
}
std::future<std::list<char>> IOCP::recv(
std::shared_ptr<Socket> sock, std::uint32_t bufsize,
std::function<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)>
callback) {
std::lock_guard lock(*GetRecvQueueMutex(sock->sock));
auto queue = GetRecvQueue(sock->sock);
Network::IOCPPASSINDATA* data;
std::packaged_task<std::list<char>(utils::ThreadPool*, IOCPPASSINDATA*)> task;
std::future<std::list<char>> future;
if (callback != nullptr) {
task = std::packaged_task<std::list<char>(utils::ThreadPool*,
IOCPPASSINDATA*)>(callback);
future = task.get_future();
data = new Network::IOCPPASSINDATA(sock, bufsize, this, std::move(task));
} else {
data = new Network::IOCPPASSINDATA(sock, bufsize, this);
}
int result = SOCKET_ERROR;
result = ::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_data->overlapped, NULL);
DWORD recvbytes = 0, flags = 0;
result = ::WSARecv(sock->sock, &data->wsabuf, 1, &recvbytes, &flags,
&data->overlapped, NULL);
if (result == SOCKET_ERROR) {
int err = ::WSAGetLastError();
if (err != WSA_IO_PENDING) {
@@ -64,82 +128,22 @@ void IOCP::registerTCPSocket(Socket& sock, std::uint32_t bufsize) {
}
}
#endif
return future;
}
void IOCP::registerUDPSocket(IOCPPASSINDATA* data, Address recv_addr) {
#ifdef _WIN32
HANDLE returnData = ::CreateIoCompletionPort(
(HANDLE)data->socket->sock, completionPort_, data->socket->sock, 0);
if (returnData == 0) completionPort_ = returnData;
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = data->socket;
DWORD recvbytes = 0, flags = 0;
int result = SOCKET_ERROR;
::WSARecvFrom(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_addr.addr, &recv_addr.length,
&recv_data->overlapped, NULL);
if (result == SOCKET_ERROR) {
int err = ::WSAGetLastError();
if (err != WSA_IO_PENDING) {
auto err_msg = std::format("WSARecv failed: {}", err);
throw std::runtime_error(err_msg);
}
}
#endif
}
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.size();
std::uint32_t copied = 0;
while (!queue->empty() && left_data != 0) {
auto front = queue->front();
queue->pop_front();
std::uint32_t offset = front.second;
std::uint32_t available = front.first.size() - offset;
std::uint32_t to_copy = (left_data < available) ? left_data : available;
::memcpy(data.data() + copied, front.first.data() + offset, to_copy);
copied += to_copy;
left_data -= to_copy;
offset += to_copy;
if (offset < front.first.size()) {
front.second = offset;
queue->push_front(front);
break;
}
}
return copied;
}
int IOCP::send(Socket& sock, std::vector<char>& data) {
auto lk = GetSendQueueMutex_(sock.sock);
auto queue = GetSendQueue_(sock.sock);
int IOCP::send(std::shared_ptr<Socket> sock, std::vector<char>& data) {
auto lk = GetSendQueueMutex(sock->sock);
auto queue = GetSendQueue(sock->sock);
std::lock_guard lock(*lk);
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(data.size());
Network::IOCPPASSINDATA* packet = new Network::IOCPPASSINDATA(sock, data.size(), this);
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 = sock.sock](utils::ThreadPool* th, std::uint8_t __) {
[this, sock = sock->sock](utils::ThreadPool* th, std::uint8_t __) {
packet_sender_(sock);
},
0);
@@ -147,7 +151,7 @@ int IOCP::send(Socket& sock, std::vector<char>& data) {
}
int IOCP::GetRecvedBytes(SOCKET sock) {
auto queue = GetRecvQueue_(sock);
auto queue = GetRecvQueue(sock);
std::lock_guard lock(socket_mod_mutex_);
int bytes = 0;
@@ -178,7 +182,15 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
data->event = IOCPEVENT::QUIT;
spdlog::debug("Disconnected. [{}]",
(std::string)(data->socket->remoteAddr));
delete data;
auto task = [this, IOCPThread, data = std::move(data)](
utils::ThreadPool* th, std::uint8_t __) {
if (data->callback.valid()) {
data->callback(th, data);
}
data->socket->destruct();
delete data;
};
IOCPThread->enqueueJob(task, 0);
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); },
0);
@@ -187,34 +199,17 @@ void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {
data->transferredbytes = cbTransfrred;
}
std::vector<char> buf(16384); // SSL_read최대 반환 크기
int red_data = 0;
std::lock_guard lock(*GetRecvQueueMutex_(sock));
auto queue_list = GetRecvQueue_(sock);
if (data->event == IOCPEVENT::READ) {
::memcpy(buf.data(), data->wsabuf.buf, data->transferredbytes);
queue_list->emplace_back(std::make_pair(
std::vector<char>(buf.begin(), buf.begin() + data->transferredbytes),
0));
DWORD recvbytes = 0, flags = 0;
IOCPPASSINDATA* recv_data = new IOCPPASSINDATA(data->bufsize);
recv_data->event = IOCPEVENT::READ;
recv_data->socket = data->socket;
auto task = [this, IOCPThread, data = std::move(data)](utils::ThreadPool* th,
std::uint8_t __) {
if (data->callback.valid()) data->callback(th, data);
delete data;
::WSARecv(recv_data->socket->sock, &recv_data->wsabuf, 1, &recvbytes,
&flags, &recv_data->overlapped, NULL);
} else { // WRITE 시, 무시한다.
spdlog::debug("writed {} bytes to {}", cbTransfrred,
(std::string)(data->socket->remoteAddr));
delete data;
}
};
IOCPThread->enqueueJob(task, 0);
IOCPThread->enqueueJob(
[this](utils::ThreadPool* th, std::uint8_t __) { iocpWatcher_(th); }, 0);
}
std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (send_queue_.find(sock) == send_queue_.end()) {
send_queue_[sock] = std::make_shared<std::list<IOCPPASSINDATA*>>(
@@ -224,7 +219,7 @@ std::shared_ptr<std::list<IOCPPASSINDATA*>> IOCP::GetSendQueue_(SOCKET sock) {
}
std::shared_ptr<std::list<std::pair<std::vector<char>, std::uint32_t>>>
IOCP::GetRecvQueue_(SOCKET sock) {
IOCP::GetRecvQueue(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (recv_queue_.find(sock) == recv_queue_.end()) {
recv_queue_[sock] = std::make_shared<
@@ -234,7 +229,7 @@ IOCP::GetRecvQueue_(SOCKET sock) {
return recv_queue_[sock];
}
std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (send_queue_mutex_.find(sock) == send_queue_mutex_.end()) {
send_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -242,7 +237,7 @@ std::shared_ptr<std::mutex> IOCP::GetSendQueueMutex_(SOCKET sock) {
return send_queue_mutex_[sock];
}
std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
if (recv_queue_mutex_.find(sock) == recv_queue_mutex_.end()) {
recv_queue_mutex_[sock] = std::make_shared<std::mutex>();
@@ -251,8 +246,8 @@ std::shared_ptr<std::mutex> IOCP::GetRecvQueueMutex_(SOCKET sock) {
}
void IOCP::packet_sender_(SOCKET sock) {
auto queue = GetSendQueue_(sock);
std::unique_lock lock(*GetSendQueueMutex_(sock));
auto queue = GetSendQueue(sock);
std::unique_lock lock(*GetSendQueueMutex(sock));
std::vector<char> buf(16384);
WSABUF wsabuf;

17
impl/socket/socket.cpp
View File

@@ -70,12 +70,13 @@ int Socket::bind(Address __addr) {
int Socket::connect(Address& serveraddr) {
std::string addr_string = serveraddr;
int retVal = -1;
if (serveraddr.family == AF_INET)
if (serveraddr.family == AF_INET) {
retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in,
serveraddr.length);
else
} else if (serveraddr.family == AF_INET6) {
retVal = ::connect(sock, (const sockaddr*)&serveraddr.addr_in6,
serveraddr.length);
}
memcpy(&remoteAddr, &serveraddr, sizeof(Address));
if (retVal == INVALID_SOCKET) {
#ifdef _WIN32
@@ -110,12 +111,6 @@ Socket::Socket(const Socket& other_) {
valid_ = false;
}
Socket::Socket(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
}
Socket& Socket::operator=(const Socket& other_) {
memcpy(this, &other_, sizeof(Socket));
valid_ = false;
@@ -123,6 +118,12 @@ Socket& Socket::operator=(const Socket& other_) {
return *this;
}
Socket::Socket(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));
valid_ = true;
}
Socket& Socket::operator=(Socket&& other_) noexcept {
other_.valid_ = false;
memcpy(this, &other_, sizeof(Socket));

28
impl/socket/tcp_socket.cpp
View File

@@ -10,35 +10,17 @@ int TCPSocket::listen(int __n) {
return retVal;
}
void TCPSocket::accept(TCPSocket &newSock, Address &__addr) {
void TCPSocket::accept(std::shared_ptr<TCPSocket> &newSock,
Address &__addr) {
SOCKET newsock = INVALID_SOCKET;
newsock = ::accept(sock, &__addr.addr, &__addr.length);
if (newsock == INVALID_SOCKET) {
spdlog::error("accept() errno:{} {}", errno, strerror(errno));
std::exit(EXIT_FAILURE);
}
newSock.set(newsock, domain);
memcpy(&newSock.remoteAddr, &__addr, sizeof(Address));
}
int TCPSocket::connect(Address &serveraddr) {
std::string addr_string = serveraddr;
int retVal = -1;
if (serveraddr.family == AF_INET)
retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in,
serveraddr.length);
else
retVal = ::connect(sock, (const sockaddr *)&serveraddr.addr_in6,
serveraddr.length);
memcpy(&remoteAddr, &serveraddr, sizeof(Address));
if (retVal == INVALID_SOCKET) {
#ifdef _WIN32
int err = WSAGetLastError();
spdlog::error("connect() failed: WSA error {} (0x{:X})", err, err);
#endif
spdlog::error("connect()");
}
return retVal;
newSock = std::make_shared<TCPSocket>();
newSock->set(newsock, domain);
newSock->remoteAddr = __addr;
}
int TCPSocket::recv(void *__restrict __buf, size_t __n, int __flags) {

2
impl/utils/generate_id.cpp
View File

@@ -9,7 +9,7 @@ static struct EpochInitializer {
std::chrono::system_clock::time_point EPOCH;
} epochInitializer;
Snowflake GenerateID(std::uint16_t instance) {
Snowflake GenerateID(std::uint8_t instance) {
static std::mutex snowflakeGenerateMutex_;
std::lock_guard<std::mutex> lock(snowflakeGenerateMutex_);

11
impl/utils/utils.cpp Normal file
View File

@@ -0,0 +1,11 @@
#include "utils/utils.h"
namespace utils {
std::vector<char> CvtListToVector(std::list<char> data) {
std::vector<char> returnValue;
returnValue.insert(returnValue.end(), data.begin(), data.end());
return returnValue;
}
}

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

@@ -53,7 +53,6 @@ std::vector<char> Model::Serialize() {
Append(buffer, angular_acceleration);
Append(buffer, scale);
Append(buffer, transform);
Append(buffer, original_offset);
Append(buffer, radius);
@@ -62,6 +61,8 @@ std::vector<char> Model::Serialize() {
Append(buffer, visible);
Append(buffer, colision);
Append(buffer, lastUpdatedTime);
return buffer;
}
@@ -81,7 +82,6 @@ void Model::Deserialize(std::vector<char> data) {
Read(data, offset, angular_acceleration);
Read(data, offset, scale);
Read(data, offset, transform);
Read(data, offset, original_offset);
Read(data, offset, radius);
@@ -89,6 +89,8 @@ void Model::Deserialize(std::vector<char> data) {
Read(data, offset, visible);
Read(data, offset, colision);
Read(data, offset, lastUpdatedTime);
}
void veng::Model::Update(float dt) {

2
impl/vulkan_engine/vulkan/buffers.cpp
View File

@@ -170,7 +170,7 @@ void Graphics::RenderIndexedBuffer(BufferHandle vertex_buffer,
vkCmdDrawIndexed(frames_[current_frame_].command_buffer, count, 1, 0, 0, 0);
SetModelMatrix(glm::mat4(1.f));
}
void Graphics::RenderModel(Model* model) {
void Graphics::RenderModel(std::shared_ptr<Model> model) {
if (!model->visible) return;
SetTexture(model->material.texture_handle);
SetModelMatrix(model->transform);

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

@@ -2,6 +2,7 @@
#include "precomp.h"
#include "socket/packet.h"
#include "utils/utils.h"
namespace veng {
@@ -36,16 +37,18 @@ const Model* Engine::GetStaticModel(std::string name) {
return nullptr;
}
Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
std::float_t lifespan) {
std::shared_ptr<Model> Engine::SpawnLifedModel(std::string asset_name,
std::string name,
std::float_t lifespan) {
if (asset_name == "") {
Model model_to_spawn(nullptr);
model_to_spawn.asset_name = "";
model_to_spawn.name = name;
model_to_spawn.visible = false;
model_to_spawn.lifespan = lifespan;
models_[name] = std::move(model_to_spawn);
return &models_[name];
models_[name] = std::make_shared<Model>(model_to_spawn);
model_to_spawn.owner = models_[name];
return models_[name];
}
if (models_.find(name) == models_.end()) {
@@ -53,8 +56,9 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
model_to_spawn.asset_name = asset_name;
model_to_spawn.name = name;
model_to_spawn.lifespan = lifespan;
models_[name] = std::move(model_to_spawn);
return &models_[name];
models_[name] = std::make_shared<Model>(model_to_spawn);
model_to_spawn.owner = models_[name];
return models_[name];
}
std::uint32_t i = 0;
@@ -64,7 +68,10 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
model_to_spawn.asset_name = asset_name;
model_to_spawn.name = name + std::to_string(i);
model_to_spawn.lifespan = lifespan;
models_[name + std::to_string(i)] = std::move(model_to_spawn);
models_[name + std::to_string(i)] =
std::make_shared<Model>(model_to_spawn);
model_to_spawn.owner = models_[name + std::to_string(i)];
break;
}
i++;
@@ -73,12 +80,12 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
if (i == std::numeric_limits<std::uint32_t>::max() - 1)
return nullptr;
else
return &models_[name + std::to_string(i)];
return models_[name + std::to_string(i)];
}
Model* Engine::GetSpawnedObject(std::string name) {
std::shared_ptr<Model> Engine::GetSpawnedObject(std::string name) {
for (auto it = models_.begin(); it != models_.end();) {
if (it->first == name) return &it->second;
if (it->first == name) return it->second;
++it;
}
@@ -110,149 +117,131 @@ void Engine::Update() {
if (Tick != nullptr) Tick(*this, delta_time);
std::vector<Model*> models;
std::vector<std::shared_ptr<Model>> models;
models.reserve(models_.size());
for (auto it = models_.begin(); it != models_.end();) {
auto& model = it->second;
if (std::abs(model.lifespan + 1.f) <
if (std::abs(model->lifespan + 1.f) <
std::numeric_limits<float>::epsilon()) {
models.push_back(&model);
models.push_back(model);
++it;
continue;
}
if (model.lifespan <= 0.f) {
if (model->lifespan <= 0.f) {
it = models_.erase(it);
continue;
}
if (model.shouldBeDestroyed) {
if (model->shouldBeDestroyed) {
it = models_.erase(it);
continue;
}
model.lifespan -= delta_time;
model->lifespan -= delta_time;
models.push_back(&model);
models.push_back(model);
++it;
}
for (auto& it : models_) {
it.second.Update(delta_time);
vulkan_graphics->RenderModel(&it.second);
it.second->Update(it.second->lastUpdatedTime + delta_time);
vulkan_graphics->RenderModel(it.second);
}
physics_controller_.invokeOnColisionEvent(thread_pool_,
{models.data(), models.size()});
physics_controller_.invokeOnColisionEvent(thread_pool_, models);
vulkan_graphics->EndFrame();
}
}
void Engine::NetUpdate(std::shared_ptr<Network::Socket> sock) {
NetworkUpload(sock);
ResponseToServerAndRefresh(sock);
}
void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
std::vector<char> data;
for (auto& it : models_) {
if (!it.second.networkReplicated) continue;
if (!it.second.needsUpdate) continue;
std::lock_guard lock(it.second->modding);
if (!it.second->networkReplicated) continue;
if (!it.second->needsUpdate) continue;
Packet::Header header;
header.opcode = Packet::Opcode::UPDATEMODEL;
std::vector<char> model = it.second.Serialize();
header.timestamp = glfwGetTime();
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());
it.second.needsUpdate = false;
it.second->needsUpdate = false;
spdlog::debug("{} uploaded", it.second->name);
}
iocp_->send(*sock, data);
iocp_->send(sock, data);
}
int recv_partial(Network::IOCP* iocp, Network::Socket& sock,
std::vector<char>& buffer) {
size_t total_received = 0;
size_t expected = buffer.size();
while (total_received < expected) {
if (total_received != 0)
Sleep(100); // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
if (sock.sock == 0) return 0;
std::vector<char> temp(expected - total_received);
size_t received = iocp->recv(sock, temp);
if (received == 0) return 0;
std::copy(temp.begin(), temp.begin() + received,
buffer.begin() + total_received);
total_received += received;
}
return total_received;
float GetAlpha(double old_time, double new_time) {
return (glfwGetTime() - old_time) / (new_time - old_time);
}
void recv_fully(Network::IOCP* iocp, Network::Socket& sock,
std::vector<char>& buffer) {
size_t total_received = 0;
size_t expected = buffer.size();
void Interpolation(Packet::Header header, std::shared_ptr<veng::Model> local,
std::shared_ptr<veng::Model> remote) {
std::lock_guard lock(local->modding);
local->position =
glm::mix(local->position, remote->position,
GetAlpha(local->lastUpdatedTime, header.timestamp));
local->linear_velocity =
glm::mix(local->linear_velocity, remote->linear_velocity,
GetAlpha(local->lastUpdatedTime, header.timestamp));
local->linear_acceleration =
glm::mix(local->linear_acceleration, remote->linear_acceleration,
GetAlpha(local->lastUpdatedTime, header.timestamp));
while (total_received < expected) {
if (total_received != 0)
Sleep(100); // 너무 빨리 재시도해서 큐가 채워질 틈이 없는 듯?
if (sock.sock == 0) return;
std::vector<char> temp(expected - total_received);
local->rotation =
glm::mix(local->rotation, remote->rotation,
GetAlpha(local->lastUpdatedTime, header.timestamp));
local->angular_velocity =
glm::mix(local->angular_velocity, remote->angular_velocity,
GetAlpha(local->lastUpdatedTime, header.timestamp));
local->angular_acceleration =
glm::mix(local->angular_acceleration, remote->angular_acceleration,
GetAlpha(local->lastUpdatedTime, header.timestamp));
size_t received = iocp->recv(sock, temp);
local->scale = glm::mix(local->scale, remote->scale,
GetAlpha(local->lastUpdatedTime, header.timestamp));
std::copy(temp.begin(), temp.begin() + received,
buffer.begin() + total_received);
total_received += received;
}
local->original_offset = remote->original_offset;
local->radius = remote->radius;
local->lifespan = remote->lifespan;
local->visible = remote->visible;
local->colision = remote->colision;
}
void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
if (sock->sock == 0) return;
std::vector<char> recv_data(6);
if (recv_partial(iocp_, *sock, recv_data) == 0) return;
auto result = iocp_->recv(sock, 14);
auto recv_data = utils::CvtListToVector(result.get()); // 여기서 막혀서 프로그램이 리턴을 못하는 문제가 있음..
Packet::Header header;
header.Deserialize(recv_data);
recv_data.resize(header.body_length);
recv_fully(iocp_, *sock, recv_data);
result = iocp_->recv(sock, header.body_length);
recv_data = utils::CvtListToVector(result.get());
switch (header.opcode) {
case Packet::Opcode::UPDATEMODEL: {
veng::Model model;
model.Deserialize(recv_data);
std::shared_ptr<veng::Model> model = std::make_shared<veng::Model>();
model->Deserialize(recv_data);
bool found = false;
for (auto& it : models_) {
if (it.second.ID == model.ID) {
it.second.position = model.position;
it.second.linear_velocity = model.linear_velocity;
it.second.linear_acceleration = model.linear_acceleration;
it.second.rotation = model.rotation;
it.second.angular_velocity = model.angular_velocity;
it.second.angular_acceleration = model.angular_acceleration;
it.second.scale = model.scale;
it.second.transform = model.transform;
it.second.original_offset = model.original_offset;
it.second.radius = model.radius;
it.second.lifespan = model.lifespan;
it.second.visible = model.visible;
it.second.colision = model.colision;
spdlog::info("model updated: {}", model.name);
spdlog::info("model pos: ({},{},{})", model.position.x,
model.position.y, model.position.z);
if (it.second->ID == model->ID) {
Interpolation(header, it.second, model);
spdlog::debug("model updated: [{}:{}]", model->name, model->ID.snowflake);
found = true;
break;
}
@@ -260,32 +249,38 @@ void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
if (!found) {
auto spawnedModel =
SpawnLifedModel(model.asset_name, model.name, model.lifespan);
spawnedModel->ID = model.ID;
spawnedModel->position = model.position;
spawnedModel->linear_velocity = model.linear_velocity;
spawnedModel->linear_acceleration = model.linear_acceleration;
SpawnLifedModel(model->asset_name, model->name, model->lifespan);
std::lock_guard lock(spawnedModel->modding);
spawnedModel->ID = model->ID;
spawnedModel->position = model->position;
spawnedModel->linear_velocity = model->linear_velocity;
spawnedModel->linear_acceleration = model->linear_acceleration;
spawnedModel->rotation = model.rotation;
spawnedModel->angular_velocity = model.angular_velocity;
spawnedModel->angular_acceleration = model.angular_acceleration;
spawnedModel->rotation = model->rotation;
spawnedModel->angular_velocity = model->angular_velocity;
spawnedModel->angular_acceleration = model->angular_acceleration;
spawnedModel->scale = model.scale;
spawnedModel->transform = model.transform;
spawnedModel->scale = model->scale;
spawnedModel->transform = model->transform;
spawnedModel->original_offset = model.original_offset;
spawnedModel->radius = model.radius;
spawnedModel->lifespan = model.lifespan;
spawnedModel->original_offset = model->original_offset;
spawnedModel->radius = model->radius;
spawnedModel->lifespan = model->lifespan;
spawnedModel->visible = model.visible;
spawnedModel->colision = model.colision;
spawnedModel->visible = model->visible;
spawnedModel->colision = model->colision;
spawnedModel->networkReplicated = false;
spdlog::info("model spawned: {}", model.ID.snowflake);
spdlog::info("model spawned: {}", model->ID.snowflake);
}
} break;
default:
spdlog::error("unknown data type");
}
thread_pool_->enqueueJob(
[this, sock](utils::ThreadPool* tp, std::uint32_t __) {
ResponseToServerAndRefresh(sock);
},
0);
}
} // namespace veng

34
impl/vulkan_engine/vulkan/physics.cpp
View File

@@ -5,34 +5,36 @@
namespace veng {
void Physics::invokeOnColisionEvent(
gsl::not_null<utils::ThreadPool*> thread_pool, gsl::span<Model*> models) {
gsl::not_null<utils::ThreadPool*> thread_pool, std::vector<std::shared_ptr<Model>> models) {
constexpr std::float_t EPSILON = std::numeric_limits<std::float_t>::epsilon();
for (int first = 0; first < models.size(); first++) {
if (!models[first]->colision) continue;
auto first_model = models[first];
if (first_model != nullptr || !first_model->colision) continue;
for (int second = first + 1; second < models.size(); second++) {
if (!models[second]->colision) continue;
auto second_model = models[second];
if (second_model != nullptr || !second_model->colision) continue;
std::float_t distance =
glm::distance(models[first]->position, models[second]->position);
std::float_t model1_radius =
models[first]->radius * models[first]->scale.x;
std::float_t model2_radius =
models[second]->radius * models[second]->scale.x;
glm::distance(first_model->position, second_model->position);
std::float_t model1_radius = first_model->radius * first_model->scale.x;
std::float_t model2_radius = second_model->radius * second_model->scale.x;
if (distance <= model1_radius + model2_radius) {
if (models[first]->OnColision != nullptr)
if (first_model->OnColision != nullptr)
thread_pool->enqueueJob(
[OnColision = models[first]->OnColision](
utils::ThreadPool* thread_pool, Model* self, Model* other) {
[OnColision = first_model->OnColision](
utils::ThreadPool* thread_pool, std::shared_ptr<Model> self,
std::shared_ptr<Model> other) {
OnColision(self, other);
},
models[first], models[second]);
if (models[second]->OnColision != nullptr)
first_model, second_model);
if (second_model->OnColision != nullptr)
thread_pool->enqueueJob(
[OnColision = models[second]->OnColision](
utils::ThreadPool* thread_pool, Model* self, Model* other) {
[OnColision = second_model->OnColision](
utils::ThreadPool* thread_pool, std::shared_ptr<Model> self,
std::shared_ptr<Model> other) {
OnColision(self, other);
},
models[second], models[first]);
first_model, second_model);
break;
}
}