직렬화 함수 작성 끝

impl/vulkan_engine/vulkan/engine.cpp

@@ -0,0 +1,177 @@
+#include "vulkan_engine/vulkan/engine.h"
+
+#include "precomp.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;
+}
+
+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];
+  }
+
+  if (dynamic_immortal_models_.find(name) == dynamic_immortal_models_.end()) {
+    Model model_to_spawn(*GetStaticModel(asset_name));
+    dynamic_immortal_models_[name] = std::move(model_to_spawn);
+    return &dynamic_immortal_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()) {
+      Model model_to_spawn(*GetStaticModel(asset_name));
+      dynamic_immortal_models_[name + std::to_string(i)] =
+          std::move(model_to_spawn);
+      break;
+    }
+    i++;
+  }
+
+  if (i == std::numeric_limits<std::uint32_t>::max() - 1)
+    return nullptr;
+  else
+    return &dynamic_immortal_models_[name + std::to_string(i)];
+}
+
+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.visible = false;
+    dynamic_models_[name] = std::make_pair(std::move(model_to_spawn), lifespan);
+    return &dynamic_models_[name].first;
+  }
+  if (dynamic_models_.find(name) == dynamic_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;
+  }
+
+  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()) {
+      Model model_to_spawn(*GetStaticModel(asset_name));
+      dynamic_models_[name + std::to_string(i)] =
+          std::make_pair(std::move(model_to_spawn), lifespan);
+      break;
+    }
+    i++;
+  }
+
+  if (i == std::numeric_limits<std::uint32_t>::max() - 1)
+    return nullptr;
+  else
+    return &dynamic_models_[name + std::to_string(i)].first;
+}
+
+Model* Engine::GetSpawnedObject(std::string name) {
+  for (auto it = dynamic_immortal_models_.begin();
+       it != dynamic_immortal_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;
+}
+
+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<Model*> models;
+    models.reserve(dynamic_immortal_models_.size() +
+                               dynamic_models_.size());
+
+    for (auto it = dynamic_immortal_models_.begin();
+         it != dynamic_immortal_models_.end();) {
+      models.push_back(&it->second);
+
+      ++it;
+    }
+
+    for (auto it = dynamic_models_.begin(); it != dynamic_models_.end();) {
+      if (it->second.second < 0.f) {
+        it = dynamic_models_.erase(it);
+        continue;
+      }
+      else {
+        it->second.second -= delta_time;
+      }
+      models.push_back(&it->second.first);
+
+      ++it;
+    }
+
+    for (auto it : models) {
+      it->Update(delta_time);
+      vulkan_graphics->RenderModel(it);
+    }
+
+    physics_controller_.invokeOnColisionEvent(thread_pool_, {models.data(), models.size()});
+
+    vulkan_graphics->EndFrame();
+  }
+}
+
+}  // namespace veng