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

아 화면 렌더링 안 되는건 memset으로 id복사하면서 버텍스 버퍼를 0으로 덮어써버리는게 원인이었음 그리고 현재 있는 버그는 너무 빠른 속도 또는 적당한 이동속도에서 총알을 많이 발사하면 카메라의 위치가 nan이 됨.

Browse Source
This commit is contained in:
HappyTanuki
2025-06-14 02:39:21 +09:00
parent 13ea246990
commit 93fda88d75
7 changed files with 168 additions and 141 deletions
Download Patch File Download Diff File Expand all files Collapse all files

10
impl/socket/iocp.cpp
View File

@@ -142,10 +142,16 @@ int IOCP::send(SOCKET sock, std::vector<IOCPPASSINDATA*>* data) {
return 0;
}
int IOCP::GetRecvedPacketCount(SOCKET sock) {
int IOCP::GetRecvedBytes(SOCKET sock) {
std::lock_guard lock(socket_mod_mutex_);
auto queue = GetRecvQueue_(sock);
return queue->size();
int bytes = 0;
for (auto it : *queue) {
bytes += it.first.size() - it.second;
}
return bytes;
}
void IOCP::iocpWatcher_(utils::ThreadPool* IOCPThread) {

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

@@ -13,64 +13,85 @@ Model::~Model() {
}
template <typename T>
static void Append(std::vector<char>& dst, const T& data) {
const char* ptr = reinterpret_cast<const char*>(&data);
dst.insert(dst.end(), ptr, ptr + sizeof(T));
}
std::vector<char> Model::Serialize() {
std::vector<char> serialized;
Append(serialized, ID);
Append(serialized, transform);
Append(serialized, position);
Append(serialized, linear_velocity);
Append(serialized, linear_acceleration);
Append(serialized, rotation);
Append(serialized, angular_velocity);
Append(serialized, angular_acceleration);
Append(serialized, scale);
Append(serialized, original_offset);
Append(serialized, radius);
uint8_t vis = visible ? 1 : 0;
uint8_t col = colision ? 1 : 0;
Append(serialized, vis);
Append(serialized, col);
return serialized;
void Append(std::vector<char>& buffer, const T& value) {
const char* data = reinterpret_cast<const char*>(&value);
buffer.insert(buffer.end(), data, data + sizeof(T));
}
template <typename T>
static void Extract(const std::vector<char>& src, size_t& offset, T& out) {
std::memcpy(&out, src.data() + offset, sizeof(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, position);
Append(buffer, linear_velocity);
Append(buffer, linear_acceleration);
Append(buffer, rotation);
Append(buffer, angular_velocity);
Append(buffer, angular_acceleration);
Append(buffer, scale);
Append(buffer, transform);
Append(buffer, original_offset);
Append(buffer, radius);
Append(buffer, lifespan);
Append(buffer, visible);
Append(buffer, colision);
return buffer;
}
void Model::Deserialize(std::vector<char> data) {
size_t offset = 0;
Extract(data, offset, ID);
ReadVector(data, offset, vertices);
ReadVector(data, offset, indices);
Extract(data, offset, transform);
Extract(data, offset, position);
Extract(data, offset, linear_velocity);
Extract(data, offset, linear_acceleration);
Extract(data, offset, rotation);
Extract(data, offset, angular_velocity);
Extract(data, offset, angular_acceleration);
Extract(data, offset, scale);
Extract(data, offset, original_offset);
Read(data, offset, position);
Read(data, offset, linear_velocity);
Read(data, offset, linear_acceleration);
Extract(data, offset, radius);
Read(data, offset, rotation);
Read(data, offset, angular_velocity);
Read(data, offset, angular_acceleration);
uint8_t vis = 0, col = 0;
Extract(data, offset, vis);
Extract(data, offset, col);
visible = vis != 0;
colision = col != 0;
Read(data, offset, scale);
Read(data, offset, transform);
Read(data, offset, original_offset);
Read(data, offset, radius);
Read(data, offset, lifespan);
Read(data, offset, visible);
Read(data, offset, colision);
}
void veng::Model::Update(float dt) {

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

@@ -1,6 +1,7 @@
#include "vulkan_engine/vulkan/engine.h"
#include "precomp.h"
#include "socket/packet.h"
namespace veng {
@@ -39,23 +40,21 @@ Model* Engine::SpawnModel(std::string asset_name, std::string name) {
if (asset_name == "") {
Model model_to_spawn(nullptr);
model_to_spawn.visible = false;
dynamic_immortal_models_[name] = std::move(model_to_spawn);
return &dynamic_immortal_models_[name];
models_[name] = std::move(model_to_spawn);
return &models_[name];
}
if (dynamic_immortal_models_.find(name) == dynamic_immortal_models_.end()) {
if (models_.find(name) == models_.end()) {
Model model_to_spawn(*GetStaticModel(asset_name));
dynamic_immortal_models_[name] = std::move(model_to_spawn);
return &dynamic_immortal_models_[name];
models_[name] = std::move(model_to_spawn);
return &models_[name];
}
std::uint32_t i = 0;
for (i = 0; i < std::numeric_limits<std::uint32_t>::max();) {
if (dynamic_immortal_models_.find(name + std::to_string(i)) ==
dynamic_immortal_models_.end()) {
if (models_.find(name + std::to_string(i)) == models_.end()) {
Model model_to_spawn(*GetStaticModel(asset_name));
dynamic_immortal_models_[name + std::to_string(i)] =
std::move(model_to_spawn);
models_[name + std::to_string(i)] = std::move(model_to_spawn);
break;
}
i++;
@@ -64,7 +63,7 @@ Model* Engine::SpawnModel(std::string asset_name, std::string name) {
if (i == std::numeric_limits<std::uint32_t>::max() - 1)
return nullptr;
else
return &dynamic_immortal_models_[name + std::to_string(i)];
return &models_[name + std::to_string(i)];
}
Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
@@ -72,22 +71,24 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
if (asset_name == "") {
Model model_to_spawn(nullptr);
model_to_spawn.visible = false;
dynamic_models_[name] = std::make_pair(std::move(model_to_spawn), lifespan);
return &dynamic_models_[name].first;
model_to_spawn.lifespan = lifespan;
models_[name] = std::move(model_to_spawn);
return &models_[name];
}
if (dynamic_models_.find(name) == dynamic_models_.end()) {
if (models_.find(name) == models_.end()) {
Model model_to_spawn(*GetStaticModel(asset_name));
dynamic_models_[name] = std::make_pair(std::move(model_to_spawn), lifespan);
return &dynamic_models_[name].first;
model_to_spawn.lifespan = lifespan;
models_[name] = std::move(model_to_spawn);
return &models_[name];
}
std::uint32_t i = 0;
for (i = 0; i < std::numeric_limits<std::uint32_t>::max();) {
if (dynamic_models_.find(name + std::to_string(i)) ==
dynamic_models_.end()) {
if (models_.find(name + std::to_string(i)) == models_.end()) {
Model model_to_spawn(*GetStaticModel(asset_name));
dynamic_models_[name + std::to_string(i)] =
std::make_pair(std::move(model_to_spawn), lifespan);
model_to_spawn.lifespan = lifespan;
models_[name + std::to_string(i)] = std::move(model_to_spawn);
break;
}
i++;
@@ -96,21 +97,15 @@ Model* Engine::SpawnLifedModel(std::string asset_name, std::string name,
if (i == std::numeric_limits<std::uint32_t>::max() - 1)
return nullptr;
else
return &dynamic_models_[name + std::to_string(i)].first;
return &models_[name + std::to_string(i)];
}
Model* Engine::GetSpawnedObject(std::string name) {
for (auto it = dynamic_immortal_models_.begin();
it != dynamic_immortal_models_.end();) {
for (auto it = models_.begin(); it != models_.end();) {
if (it->first == name) return &it->second;
++it;
}
for (auto it = dynamic_models_.begin(); it != dynamic_models_.end();) {
if (it->first == name) return &it->second.first;
++it;
}
return nullptr;
}
@@ -140,46 +135,74 @@ void Engine::Update() {
if (Tick != nullptr) Tick(*this, delta_time);
std::vector<Model*> models;
models.reserve(dynamic_immortal_models_.size() +
dynamic_models_.size());
models.reserve(models_.size());
for (auto it = dynamic_immortal_models_.begin();
it != dynamic_immortal_models_.end();) {
models.push_back(&it->second);
for (auto it = models_.begin(); it != models_.end();) {
auto& model = it->second;
++it;
}
for (auto it = dynamic_models_.begin(); it != dynamic_models_.end();) {
if (it->second.second < 0.f) {
it = dynamic_models_.erase(it);
if (std::abs(model.lifespan + 1.f) <
std::numeric_limits<float>::epsilon()) {
models.push_back(&model);
++it;
continue;
}
else {
it->second.second -= delta_time;
}
models.push_back(&it->second.first);
if (model.lifespan <= 0.f) {
it = models_.erase(it);
continue;
}
model.lifespan -= delta_time;
models.push_back(&model);
++it;
}
for (auto it : models) {
it->Update(delta_time);
vulkan_graphics->RenderModel(it);
for (auto& it : models_) {
it.second.Update(delta_time);
vulkan_graphics->RenderModel(&it.second);
}
physics_controller_.invokeOnColisionEvent(thread_pool_, {models.data(), models.size()});
physics_controller_.invokeOnColisionEvent(thread_pool_,
{models.data(), models.size()});
vulkan_graphics->EndFrame();
}
}
void Engine::NetworkUpload() {
//TODO: 작성하기
void Engine::NetUpdate(std::shared_ptr<Network::Socket> sock) {
NetworkUpload(sock);
RefreshFromServer(sock);
}
void Engine::RefreshFromServer() {
// TODO: 작성하기
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);
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);
}
iocp_->send(sock->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);
}
} // namespace veng