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 17:34:34 +09:00
parent dc2c106bad
commit 3e3769f912
8 changed files with 81 additions and 73 deletions
Download Patch File Download Diff File Expand all files Collapse all files

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

@@ -20,15 +20,16 @@ void Engine::init() {
}
void Engine::LoadModelAsset(std::string path, std::string name) {
veng::Model model(vulkan_graphics);
model_assets_[name] = veng::Model(vulkan_graphics);
asset_loader_.setPath(path);
asset_loader_.loadModel(model);
asset_loader_.loadModel(model_assets_[name]);
model.vertex_buffer = vulkan_graphics->CreateVertexBuffer(model.vertices);
model.index_buffer = vulkan_graphics->CreateIndexBuffer(model.indices);
model.material.texture_handle =
model_assets_[name].vertex_buffer =
vulkan_graphics->CreateVertexBuffer(model_assets_[name].vertices);
model_assets_[name].index_buffer =
vulkan_graphics->CreateIndexBuffer(model_assets_[name].indices);
model_assets_[name].material.texture_handle =
vulkan_graphics->CreateTexture(asset_loader_.readTexture());
model_assets_[name] = std::move(model);
}
const Model* Engine::GetStaticModel(std::string name) {
@@ -117,15 +118,11 @@ void Engine::Update() {
if (Tick != nullptr) Tick(*this, delta_time);
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) <
std::numeric_limits<float>::epsilon()) {
models.push_back(model);
++it;
continue;
}
@@ -141,8 +138,6 @@ void Engine::Update() {
}
model->lifespan -= delta_time;
models.push_back(model);
++it;
}
@@ -151,7 +146,7 @@ void Engine::Update() {
vulkan_graphics->RenderModel(it.second);
}
physics_controller_.invokeOnColisionEvent(thread_pool_, models);
physics_controller_.invokeOnColisionEvent(thread_pool_, models_);
vulkan_graphics->EndFrame();
}
@@ -176,11 +171,10 @@ void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
data.insert(data.end(), header_serialized.begin(), header_serialized.end());
data.insert(data.end(), model.begin(), model.end());
if (it.second->updateRedundantCount >= 2) {
if (it.second->updateRedundantCount <= 1) {
it.second->needsUpdate = false;
it.second->updateRedundantCount = 0;
} else {
it.second->updateRedundantCount++;
it.second->updateRedundantCount--;
}
spdlog::debug("{} uploaded", it.second->name);
}
@@ -188,7 +182,7 @@ void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
}
float GetAlpha(double old_time, double new_time) {
return (glfwGetTime() - old_time) / (new_time - old_time);
return (glfwGetTime() - old_time) / (new_time - old_time) * 0.5;
}
void Interpolation(Packet::Header header, std::shared_ptr<veng::Model> local,
@@ -256,17 +250,8 @@ void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
auto spawnedModel =
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->scale = model->scale;
spawnedModel->transform = model->transform;
spawnedModel->original_offset = model->original_offset;
spawnedModel->radius = model->radius;
@@ -275,6 +260,8 @@ void Engine::ResponseToServerAndRefresh(std::shared_ptr<Network::Socket> sock) {
spawnedModel->visible = model->visible;
spawnedModel->colision = model->colision;
spawnedModel->networkReplicated = false;
Interpolation(header, spawnedModel, model);
spdlog::info("model spawned: {}", model->ID.snowflake);
}
} break;

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

@@ -5,37 +5,27 @@
namespace veng {
void Physics::invokeOnColisionEvent(
gsl::not_null<utils::ThreadPool*> thread_pool, std::vector<std::shared_ptr<Model>> models) {
gsl::not_null<utils::ThreadPool*> thread_pool,
std::unordered_map<std::string, 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++) {
auto first_model = models[first];
if (first_model != nullptr || !first_model->colision) continue;
for (int second = first + 1; second < models.size(); second++) {
auto second_model = models[second];
if (second_model != nullptr || !second_model->colision) continue;
for (std::unordered_map<std::string, std::shared_ptr<Model>>::iterator
iter_A = models.begin();
iter_A != models.end(); iter_A++) {
auto model_A = iter_A->second;
if (!model_A->colision) continue;
for (auto iter_B = std::next(iter_A); iter_B != models.end(); iter_B++) {
auto model_B = iter_B->second;
if (!model_B->colision) continue;
std::float_t distance =
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 (first_model->OnColision != nullptr)
thread_pool->enqueueJob(
[OnColision = first_model->OnColision](
utils::ThreadPool* thread_pool, std::shared_ptr<Model> self,
std::shared_ptr<Model> other) {
OnColision(self, other);
},
first_model, second_model);
if (second_model->OnColision != nullptr)
thread_pool->enqueueJob(
[OnColision = second_model->OnColision](
utils::ThreadPool* thread_pool, std::shared_ptr<Model> self,
std::shared_ptr<Model> other) {
OnColision(self, other);
},
first_model, second_model);
break;
glm::distance(model_A->position, model_B->position);
std::float_t modelA_radius = model_A->radius * model_A->scale.x;
std::float_t modelB_radius = model_B->radius * model_B->scale.x;
if (distance <= modelA_radius + modelB_radius) {
if (model_A->OnColision)
thread_pool->enqueueJob(model_A->OnColision, model_A, model_B);
if (model_B->OnColision)
thread_pool->enqueueJob(model_B->OnColision, model_A, model_B);
}
}
}