287 lines
9.4 KiB
C++
287 lines
9.4 KiB
C++
#include "vulkan_engine/vulkan/engine.h"
|
|
|
|
#include "precomp.h"
|
|
#include "socket/packet.h"
|
|
#include "utils/utils.h"
|
|
|
|
namespace veng {
|
|
|
|
void Engine::init() {
|
|
glm::ivec2 window_size_ = vulkan_graphics->window->GetFramebufferSize();
|
|
view = glm::lookAt(glm::vec3(0.f, 0.f, -5.f), glm::vec3(0.f, 0.f, 0.f),
|
|
glm::vec3(0.f, -1.f, 0.f));
|
|
projection = glm::perspective(
|
|
glm::radians(103.f),
|
|
(std::float_t)window_size_.x / (std::float_t)window_size_.y, 0.1f,
|
|
1000.f);
|
|
vulkan_graphics->SetViewProjection(view, projection);
|
|
|
|
if (BeginPlay != nullptr) BeginPlay(*this);
|
|
}
|
|
|
|
void Engine::LoadModelAsset(std::string path, std::string name) {
|
|
veng::Model model(vulkan_graphics);
|
|
asset_loader_.setPath(path);
|
|
asset_loader_.loadModel(model);
|
|
|
|
model.vertex_buffer = vulkan_graphics->CreateVertexBuffer(model.vertices);
|
|
model.index_buffer = vulkan_graphics->CreateIndexBuffer(model.indices);
|
|
model.material.texture_handle =
|
|
vulkan_graphics->CreateTexture(asset_loader_.readTexture());
|
|
model_assets_[name] = std::move(model);
|
|
}
|
|
|
|
const Model* Engine::GetStaticModel(std::string name) {
|
|
if (model_assets_.find(name) != model_assets_.end())
|
|
return &model_assets_[name];
|
|
return nullptr;
|
|
}
|
|
|
|
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::make_shared<Model>(model_to_spawn);
|
|
model_to_spawn.owner = models_[name];
|
|
return models_[name];
|
|
}
|
|
|
|
if (models_.find(name) == models_.end()) {
|
|
Model model_to_spawn(*GetStaticModel(asset_name));
|
|
model_to_spawn.asset_name = asset_name;
|
|
model_to_spawn.name = name;
|
|
model_to_spawn.lifespan = lifespan;
|
|
models_[name] = std::make_shared<Model>(model_to_spawn);
|
|
model_to_spawn.owner = models_[name];
|
|
return models_[name];
|
|
}
|
|
|
|
std::uint32_t i = 0;
|
|
for (i = 0; i < std::numeric_limits<std::uint32_t>::max();) {
|
|
if (models_.find(name + std::to_string(i)) == models_.end()) {
|
|
Model model_to_spawn(*GetStaticModel(asset_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::make_shared<Model>(model_to_spawn);
|
|
model_to_spawn.owner = models_[name + std::to_string(i)];
|
|
break;
|
|
}
|
|
i++;
|
|
}
|
|
|
|
if (i == std::numeric_limits<std::uint32_t>::max() - 1)
|
|
return nullptr;
|
|
else
|
|
return models_[name + std::to_string(i)];
|
|
}
|
|
|
|
std::shared_ptr<Model> Engine::GetSpawnedObject(std::string name) {
|
|
for (auto it = models_.begin(); it != models_.end();) {
|
|
if (it->first == name) return it->second;
|
|
++it;
|
|
}
|
|
|
|
return nullptr;
|
|
}
|
|
|
|
void Engine::Update() {
|
|
glm::ivec2 framebuffer_size = vulkan_graphics->window->GetFramebufferSize();
|
|
if (framebuffer_size != window_size_ && framebuffer_size.x != 0 &&
|
|
framebuffer_size.y != 0) {
|
|
window_size_ = framebuffer_size;
|
|
auto grater = (framebuffer_size.x > framebuffer_size.y)
|
|
? framebuffer_size.x
|
|
: framebuffer_size.y;
|
|
view = glm::lookAt(glm::vec3(0.f, 0.f, -5.f), glm::vec3(0.f, 0.f, 0.f),
|
|
glm::vec3(0.f, -1.f, 0.f));
|
|
projection = glm::perspective(
|
|
glm::radians(103.f),
|
|
(std::float_t)framebuffer_size.x / (std::float_t)framebuffer_size.y,
|
|
0.1f, 1000.f);
|
|
}
|
|
vulkan_graphics->SetViewProjection(view, projection);
|
|
|
|
if (vulkan_graphics->BeginFrame()) {
|
|
std::double_t current_time = glfwGetTime();
|
|
std::float_t delta_time =
|
|
static_cast<std::float_t>(current_time - last_frame_time_);
|
|
last_frame_time_ = current_time;
|
|
|
|
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;
|
|
}
|
|
|
|
if (model->lifespan <= 0.f) {
|
|
it = models_.erase(it);
|
|
continue;
|
|
}
|
|
|
|
if (model->shouldBeDestroyed) {
|
|
it = models_.erase(it);
|
|
continue;
|
|
}
|
|
|
|
model->lifespan -= delta_time;
|
|
|
|
models.push_back(model);
|
|
++it;
|
|
}
|
|
|
|
for (auto& it : models_) {
|
|
it.second->Update(it.second->lastUpdatedTime + delta_time);
|
|
vulkan_graphics->RenderModel(it.second);
|
|
}
|
|
|
|
physics_controller_.invokeOnColisionEvent(thread_pool_, models);
|
|
|
|
vulkan_graphics->EndFrame();
|
|
}
|
|
}
|
|
void Engine::NetUpdate(std::shared_ptr<Network::Socket> sock) {
|
|
NetworkUpload(sock);
|
|
}
|
|
|
|
void Engine::NetworkUpload(std::shared_ptr<Network::Socket> sock) {
|
|
std::vector<char> data;
|
|
for (auto& it : models_) {
|
|
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;
|
|
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;
|
|
spdlog::debug("{} uploaded", it.second->name);
|
|
}
|
|
iocp_->send(sock, data);
|
|
}
|
|
|
|
float GetAlpha(double old_time, double new_time) {
|
|
return (glfwGetTime() - old_time) / (new_time - old_time);
|
|
}
|
|
|
|
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));
|
|
|
|
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));
|
|
|
|
local->scale = glm::mix(local->scale, remote->scale,
|
|
GetAlpha(local->lastUpdatedTime, header.timestamp));
|
|
|
|
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;
|
|
|
|
auto result = iocp_->recv(sock, 14);
|
|
auto recv_data = utils::CvtListToVector(result.get()); // 여기서 막혀서 프로그램이 리턴을 못하는 문제가 있음..
|
|
|
|
Packet::Header header;
|
|
header.Deserialize(recv_data);
|
|
|
|
result = iocp_->recv(sock, header.body_length);
|
|
recv_data = utils::CvtListToVector(result.get());
|
|
|
|
switch (header.opcode) {
|
|
case Packet::Opcode::UPDATEMODEL: {
|
|
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) {
|
|
Interpolation(header, it.second, model);
|
|
spdlog::debug("model updated: [{}:{}]", model->name, model->ID.snowflake);
|
|
found = true;
|
|
break;
|
|
}
|
|
}
|
|
|
|
if (!found) {
|
|
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;
|
|
spawnedModel->lifespan = model->lifespan;
|
|
|
|
spawnedModel->visible = model->visible;
|
|
spawnedModel->colision = model->colision;
|
|
spawnedModel->networkReplicated = false;
|
|
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
|