vulkan instance 까지 생성 완료

CMakeLists.txt

@@ -30,8 +30,10 @@ FetchContent_Declare(
 FetchContent_MakeAvailable(GSL)
 
 file(GLOB_RECURSE VulkanEngineSources CONFIGURE_DEPENDS
+    "${CMAKE_CURRENT_SOURCE_DIR}/include/*.h"
     "${CMAKE_CURRENT_SOURCE_DIR}/src/*.cpp"
-    "${CMAKE_CURRENT_SOURCE_DIR}/src/*.h"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/glfw/*.cpp"
+    "${CMAKE_CURRENT_SOURCE_DIR}/src/vulkan/*.cpp"
 )
 
 add_executable(VulkanEngine ${VulkanEngineSources})
@@ -40,5 +42,7 @@ target_link_libraries(VulkanEngine PRIVATE glm)
 target_link_libraries(VulkanEngine PRIVATE glfw)
 target_link_libraries(VulkanEngine PRIVATE Microsoft.GSL::GSL)
 
-target_include_directories(VulkanEngine PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/src")
+target_include_directories(VulkanEngine PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include")
-target_compile_features(VulkanEngine PRIVATE cxx_std_20)
+target_compile_features(VulkanEngine PRIVATE cxx_std_20)
+
+target_precompile_headers(VulkanEngine PRIVATE "${CMAKE_CURRENT_SOURCE_DIR}/include/precomp.h")

include/glfw/glfw_initialization.h

@@ -0,0 +1,12 @@
+#pragma once
+
+namespace veng {
+struct GlfwInitialization {
+ public:
+  GlfwInitialization();
+  ~GlfwInitialization();
+
+  GlfwInitialization(const GlfwInitialization&) = delete;
+  GlfwInitialization& operator=(const GlfwInitialization&) = delete;
+};
+}  // namespace veng

include/glfw/glfw_monitor.h

@@ -0,0 +1,12 @@
+#pragma once
+
+struct GLFWmonitor;
+struct GLFWwindow;
+
+namespace veng {
+gsl::span<GLFWmonitor *> GetMonitors();
+glm::ivec2 GetMonitorPosition(gsl::not_null<GLFWmonitor *> monitor);
+glm::ivec2 GetMonitorWorkAreaSize(gsl::not_null<GLFWmonitor *> monitor);
+void MoveWindowToMonitor(gsl::not_null<GLFWwindow *> window,
+                         gsl::not_null<GLFWmonitor *> monitor);
+}  // namespace veng

include/glfw/glfw_window.h

@@ -0,0 +1,21 @@
+#pragma once
+
+struct GLFWmonitor;
+struct GLFWwindow;
+
+namespace veng {
+class Window {
+ public:
+  Window(gsl::czstring name, glm::ivec2 size);
+  ~Window();
+
+  glm::ivec2 GetWindowSize() const;
+  bool ShouldClose() const;
+  GLFWwindow* GetHandle() const;
+
+  bool TryMoveToMonitor(std::uint16_t monitor_number);
+
+ private:
+  GLFWwindow* window_;
+};
+}  // namespace veng

include/precomp.h

@@ -0,0 +1,8 @@
+#pragma once
+#include <cmath>
+#include <cstdint>
+#include <cstdlib>
+#include <glm/glm.hpp>
+#include <gsl/gsl>
+#include <string>
+#include <string_view>

include/vulkan/graphics.h

@@ -0,0 +1,20 @@
+#pragma once
+#include <vulkan/vulkan.h>
+#include "glfw/glfw_window.h"
+
+namespace veng {
+class Graphics final {
+ public:
+  Graphics(gsl::not_null<Window *> window);
+  ~Graphics();
+
+ private:
+  void InitializeVulkan();
+  void CreateInstance();
+
+  gsl::span<gsl::czstring> GetSuggestedExtentions();
+
+  VkInstance instance_ = nullptr;
+  gsl::not_null<Window *> window_;
+};
+}  // namespace veng

src/glfw/glfw_initialization.cpp

@@ -0,0 +1,14 @@
+#include "glfw/glfw_initialization.h"
+
+#include <GLFW/glfw3.h>
+
+#include <cstdlib>
+
+#include "precomp.h"
+
+namespace veng {
+GlfwInitialization::GlfwInitialization() {
+  if (glfwInit() != GLFW_TRUE) std::exit(EXIT_FAILURE);
+}
+GlfwInitialization::~GlfwInitialization() { glfwTerminate(); }
+}  // namespace veng

src/glfw/glfw_moniotr.cpp

@@ -0,0 +1,34 @@
+#include <GLFW/glfw3.h>
+
+#include "glfw/glfw_monitor.h"
+#include "precomp.h"
+
+namespace veng {
+gsl::span<GLFWmonitor *> GetMonitors() {
+  std::int32_t monitor_count = 0;
+  GLFWmonitor **monitor_pointers = glfwGetMonitors(&monitor_count);
+  return gsl::span<GLFWmonitor *>(monitor_pointers, monitor_count);
+}
+
+glm::ivec2 GetMonitorPosition(gsl::not_null<GLFWmonitor *> monitor) {
+  glm::ivec2 monitor_position;
+  glfwGetMonitorPos(monitor, &monitor_position.x, &monitor_position.y);
+  return monitor_position;
+}
+glm::ivec2 GetMonitorWorkAreaSize(gsl::not_null<GLFWmonitor *> monitor) {
+  glm::ivec2 monitor_size;
+  glfwGetMonitorWorkarea(monitor, nullptr, nullptr, &monitor_size.x,
+                         &monitor_size.y);
+  return monitor_size;
+}
+
+void MoveWindowToMonitor(gsl::not_null<GLFWwindow *> window,
+                         gsl::not_null<GLFWmonitor *> monitor) {
+  glm::ivec2 window_size;
+  glfwGetWindowSize(window, &window_size.x, &window_size.y);
+  const glm::ivec2 window_new_position = GetMonitorPosition(monitor) +
+                                         (GetMonitorWorkAreaSize(monitor) / 2) -
+                                         (window_size / 2);
+  glfwSetWindowPos(window, window_new_position.x, window_new_position.y);
+}
+}  // namespace veng

src/glfw/glfw_window.cpp

@@ -0,0 +1,39 @@
+#include <GLFW/glfw3.h>
+
+#include "glfw/glfw_monitor.h"
+#include "glfw/glfw_window.h"
+#include "precomp.h"
+
+namespace veng {
+
+Window::Window(gsl::czstring name, glm::ivec2 size) {
+  glfwWindowHint(GLFW_RESIZABLE, GLFW_FALSE);
+  glfwWindowHint(GLFW_CLIENT_API, GLFW_NO_API);
+
+  window_ = glfwCreateWindow(size.x, size.y, name, nullptr, nullptr);
+  if (window_ == nullptr) std::exit(EXIT_FAILURE);
+}
+
+Window::~Window() { glfwDestroyWindow(window_); }
+
+glm::ivec2 Window::GetWindowSize() const {
+  glm::ivec2 window_size;
+  glfwGetWindowSize(window_, &window_size.x, &window_size.y);
+  return window_size;
+}
+
+bool Window::ShouldClose() const { return glfwWindowShouldClose(window_); }
+
+GLFWwindow* Window::GetHandle() const { return window_; }
+
+bool Window::TryMoveToMonitor(std::uint16_t monitor_number) {
+  gsl::span<GLFWmonitor*> monitors = veng::GetMonitors();
+
+  if (monitor_number < monitors.size()) {
+    veng::MoveWindowToMonitor(window_, monitors[monitor_number]);
+    return true;
+  }
+  return false;
+}
+
+}  // namespace veng

src/main.cpp

@@ -1,19 +1,21 @@
 #include <GLFW/glfw3.h>
-#include <vulkan/vulkan.h>
 
-#include <cmath>
+#include "glfw/glfw_initialization.h"
-#include <cstdint>
+#include "glfw/glfw_monitor.h"
-#include <filesystem>
+#include "glfw/glfw_window.h"
-#include <glm/glm.hpp>
+#include "vulkan/graphics.h"
-#include <gsl/gsl>
-#include <iostream>
 
-int main(std::int32_t argc, gsl::zstring* argv) {
+std::int32_t main(std::int32_t argc, gsl::zstring* argv) {
-  gsl::span<gsl::zstring> arguments(argv, argc);
+  const veng::GlfwInitialization _glfw;
-  std::sort(arguments.begin(), arguments.end());
 
-  gsl::not_null<gsl::zstring*> arguments_pointer_validated = argv;
+  veng::Window window("Vulkan Engine", {800, 600});
+  window.TryMoveToMonitor(0);
 
-  std::cout << "Hello, World!" << std::endl;
+  veng::Graphics graphics(&window);
-  return 0;
+
-}
+  while (!window.ShouldClose()) {
+    glfwPollEvents();
+  }
+
+  return EXIT_SUCCESS;
+}

src/vulkan/graphics.cpp

@@ -0,0 +1,51 @@
+#include "vulkan/graphics.h"
+
+#include <GLFW/glfw3.h>
+
+#include "precomp.h"
+
+namespace veng {
+
+Graphics::Graphics(gsl::not_null<Window*> window) : window_(window) {
+  InitializeVulkan();
+}
+
+Graphics::~Graphics() {
+  if (instance_ != nullptr) vkDestroyInstance(instance_, nullptr);
+}
+
+void Graphics::InitializeVulkan() { CreateInstance(); }
+
+void Graphics::CreateInstance() {
+  gsl::span<gsl::czstring> suggested_extentions = GetSuggestedExtentions();
+
+  VkApplicationInfo app_info = {};
+  app_info.sType = VK_STRUCTURE_TYPE_APPLICATION_INFO;
+  app_info.pNext = nullptr;
+  app_info.pApplicationName = "Udemy Course";
+  app_info.applicationVersion = VK_MAKE_API_VERSION(0, 0, 0, 0);
+  app_info.pEngineName = "VEng";
+  app_info.engineVersion = VK_MAKE_API_VERSION(0, 1, 0, 0);
+  app_info.apiVersion = VK_API_VERSION_1_0;
+
+  VkInstanceCreateInfo instance_creation_info = {};
+  instance_creation_info.sType = VK_STRUCTURE_TYPE_INSTANCE_CREATE_INFO;
+  instance_creation_info.pNext = nullptr;
+  instance_creation_info.pApplicationInfo = &app_info;
+  instance_creation_info.enabledExtensionCount = suggested_extentions.size();
+  instance_creation_info.ppEnabledExtensionNames = suggested_extentions.data();
+  instance_creation_info.enabledLayerCount = 0;
+
+  VkResult result =
+      vkCreateInstance(&instance_creation_info, nullptr, &instance_);
+  if (result != VK_SUCCESS) std::exit(EXIT_FAILURE);
+}
+
+gsl::span<gsl::czstring> Graphics::GetSuggestedExtentions() {
+  std::uint32_t glfw_extention_count = 0;
+  gsl::czstring* glfw_extentions =
+      glfwGetRequiredInstanceExtensions(&glfw_extention_count);
+  return {glfw_extentions, glfw_extention_count};
+}
+
+}  // namespace veng