Feat: init Win32 window plugin

Author: imbobz

plugins/Window/CMakeLists.txt

@@ -1,2 +1,3 @@
 add_subdirectory(GLFW)
+add_subdirectory(Win32)
 add_subdirectory(X11)

plugins/Window/Win32/CMakeLists.txt

@@ -0,0 +1,33 @@
+project(cae-window-win32
+        DESCRIPTION "CAE Win32 Window Plugin"
+        LANGUAGES C CXX
+)
+
+if (NOT WIN32)
+    message(WARNING "${PROJECT_NAME} can only be build on windows")
+    return()
+endif ()
+
+find_library(USER32_LIB user32)
+find_library(GDI32_LIB gdi32)
+
+file(GLOB_RECURSE SOURCE "${PROJECT_SOURCE_DIR}/src/*.cpp")
+file(GLOB_RECURSE HEADERS "${PROJECT_SOURCE_DIR}/include/*.hpp")
+
+add_library(${PROJECT_NAME} SHARED
+        ${SOURCE}
+        ${HEADERS}
+)
+
+target_include_directories(${PROJECT_NAME} PRIVATE "${PROJECT_SOURCE_DIR}/include")
+target_compile_options(${PROJECT_NAME} PRIVATE ${WARNING_FLAGS})
+target_compile_features(${PROJECT_NAME} PRIVATE cxx_std_23)
+target_link_libraries(${PROJECT_NAME} PRIVATE
+        cae-modules
+        ${USER32_LIB}
+        ${GDI32_LIB}
+)
+set_target_properties(${PROJECT_NAME} PROPERTIES
+        LIBRARY_OUTPUT_DIRECTORY "${PLUGIN_DIR}"
+        RUNTIME_OUTPUT_DIRECTORY "${PLUGIN_DIR}"
+)

plugins/Window/Win32/include/Win32/Win32.hpp

@@ -0,0 +1,61 @@
+///
+/// @file Win32.hpp
+/// @brief This file contains the Win32 class declaration
+/// @namespace cae
+///
+
+#pragma once
+
+#include <windows.h>
+
+#include "Interfaces/IWindow.hpp"
+
+namespace cae
+{
+
+    ///
+    /// @class Win32
+    /// @brief Class for the Win32 plugin
+    /// @namespace cae
+    ///
+    class Win32 final : public IWindow
+    {
+
+        public:
+            Win32() = default;
+            ~Win32() override = default;
+
+            Win32(const Win32 &) = delete;
+            Win32 &operator=(const Win32 &) = delete;
+            Win32(Win32 &&) = delete;
+            Win32 &operator=(Win32 &&) = delete;
+
+            [[nodiscard]] std::string getName() const override { return "Win32"; }
+            [[nodiscard]] utl::PluginType getType() const override { return utl::PluginType::WINDOW; }
+            [[nodiscard]] utl::PluginPlatform getPlatform() const override { return utl::PluginPlatform::WINDOWS; }
+
+            bool create(const std::string &name, WindowSize size) override;
+            void close() override;
+
+            [[nodiscard]] NativeWindowHandle getNativeHandle() const override;
+            [[nodiscard]] WindowSize getWindowSize() const override;
+
+            [[nodiscard]] bool setIcon(const std::string &path) const override;
+
+        [[nodiscard]] bool shouldClose() const override { return m_shouldClose; }
+            void pollEvents() override;
+
+            bool wasResized() const override { return m_frameBufferResized; }
+            void resetResizedFlag() override { m_frameBufferResized = false; }
+
+        private:
+            static LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam);
+
+            HWND m_hwnd = nullptr;
+            HINSTANCE m_hInstance = nullptr;
+            WindowSize m_frameBufferSize;
+            bool m_frameBufferResized = false;
+            bool m_shouldClose = false;
+
+    }; // class Win32
+} // namespace cae

plugins/Window/Win32/src/entrypoint.cpp

@@ -0,0 +1,8 @@
+#include <memory>
+
+#include "Win32/Win32.hpp"
+
+extern "C"
+{
+    PLUGIN_EXPORT cae::IWindow *entryPoint() { return std::make_unique<cae::Win32>().release(); }
+}

plugins/Window/Win32/src/win32.cpp

@@ -0,0 +1,120 @@
+#include <string>
+
+#include <Utils/Logger.hpp>
+
+#include "Win32/Win32.hpp"
+
+LRESULT CALLBACK cae::Win32::WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
+{
+    auto* self = reinterpret_cast<Win32*>(GetWindowLongPtr(hwnd, GWLP_USERDATA));
+
+    switch (msg)
+    {
+        case WM_CLOSE:
+            if (self) self->m_shouldClose = true;
+            return 0;
+        case WM_SIZE:
+            if (self)
+            {
+                self->m_frameBufferResized = true;
+                self->m_frameBufferSize.width = LOWORD(lParam);
+                self->m_frameBufferSize.height = HIWORD(lParam);
+            }
+            return 0;
+        case WM_DESTROY:
+            PostQuitMessage(0);
+            return 0;
+        default:
+            return DefWindowProc(hwnd, msg, wParam, lParam);
+    }
+}
+
+bool cae::Win32::create(const std::string &name, WindowSize size)
+{
+    m_hInstance = GetModuleHandle(nullptr);
+    m_frameBufferSize = size;
+    m_shouldClose = false;
+    m_frameBufferResized = false;
+
+    WNDCLASSW wc{};
+    wc.lpfnWndProc = WindowProc;
+    wc.hInstance = m_hInstance;
+    wc.lpszClassName = L"CAE_WindowsWindowClass";
+    wc.hCursor = LoadCursor(nullptr, IDC_ARROW);
+    wc.hIcon = LoadIcon(nullptr, IDI_APPLICATION);
+    wc.hbrBackground = reinterpret_cast<HBRUSH>(COLOR_WINDOW + 1);
+
+    if (!RegisterClassW(&wc) && GetLastError() != ERROR_CLASS_ALREADY_EXISTS)
+    {
+        utl::Logger::log("Failed to register window class", utl::LogLevel::WARNING);
+        return false;
+    }
+
+    m_hwnd = CreateWindowEx(
+        0,
+        reinterpret_cast<LPCSTR>(L"CAE_WindowsWindowClass"),
+        reinterpret_cast<LPCSTR>(std::wstring(name.begin(), name.end()).c_str()),
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT, CW_USEDEFAULT,
+        size.width, size.height,
+        nullptr,
+        nullptr,
+        m_hInstance,
+        nullptr
+    );
+
+    if (!m_hwnd)
+    {
+        utl::Logger::log("Failed to create Win32 window", utl::LogLevel::WARNING);
+        return false;
+    }
+
+    SetWindowLongPtr(m_hwnd, GWLP_USERDATA, reinterpret_cast<LONG_PTR>(this));
+    ShowWindow(m_hwnd, SW_SHOW);
+    UpdateWindow(m_hwnd);
+
+    return true;
+}
+
+void cae::Win32::close()
+{
+    if (m_hwnd)
+    {
+        DestroyWindow(m_hwnd);
+        m_hwnd = nullptr;
+    }
+    UnregisterClass(reinterpret_cast<LPCSTR>(L"CAE_WindowsWindowClass"), m_hInstance);
+}
+
+ cae::NativeWindowHandle cae::Win32::getNativeHandle() const
+{
+    return {.window = m_hwnd, .display = m_hInstance};
+
+}
+
+ cae::WindowSize cae::Win32::getWindowSize() const
+{
+    RECT rect{};
+    GetClientRect(m_hwnd, &rect);
+    return {.width = static_cast<uint16_t>(rect.right - rect.left),
+            .height = static_cast<uint16_t>(rect.bottom - rect.top)};
+}
+
+ bool cae::Win32::setIcon(const std::string &path) const
+{
+    return false;
+}
+
+void cae::Win32::pollEvents()
+{
+    MSG msg{};
+    while (PeekMessage(&msg, nullptr, 0, 0, PM_REMOVE))
+    {
+        if (msg.message == WM_QUIT)
+        {
+            m_shouldClose = true;
+        }
+        TranslateMessage(&msg);
+        DispatchMessage(&msg);
+    }
+}