OpenGL: Refactor integration test and enable CTest framework

- Simplify OpenGL integration test structure
- Enable CTest registration for OpenGL tests
- Refactor test fixtures and device enumeration
- Minor code cleanup and improvements

engine/include/XCEngine/RHI/OpenGL/OpenGLBuffer.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <GLFW/glfw3.h>
 
 #include "../RHIBuffer.h"
 

engine/include/XCEngine/RHI/OpenGL/OpenGLCommandList.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <vector>
 #include <cstdint>
 

engine/include/XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <cstdint>
 
 namespace XCEngine {

engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h

@@ -1,14 +1,21 @@
 #pragma once
 
 #include <string>
-#include <GLFW/glfw3.h>
 
 #include "../RHIDevice.h"
 #include "../RHICapabilities.h"
 
+struct HWND__;
+struct HDC__;
+struct HGLRC__;
+
 namespace XCEngine {
 namespace RHI {
 
+using HWND = HWND__*;
+using HDC = HDC__*;
+using HGLRC = HGLRC__*;
+
 class OpenGLDevice : public RHIDevice {
 public:
     OpenGLDevice();
@@ -18,9 +25,11 @@ public:
     void Shutdown() override;
 
     bool CreateRenderWindow(int width, int height, const char* title, bool enableDebug = false);
-    bool InitializeWithExistingWindow(GLFWwindow* window);
+    bool InitializeWithExistingWindow(HWND hwnd);
 
-    GLFWwindow* GetWindow() const { return m_window; }
+    HWND GetWindow() const { return m_hwnd; }
+    HDC GetDC() const { return m_hdc; }
+    HGLRC GetContext() const { return m_hglrc; }
     const RHIDeviceInfo& GetDeviceInfoImpl() const { return m_deviceInfo; }
 
     void SwapBuffers();
@@ -45,12 +54,15 @@ public:
     void* GetNativeHandle() const;
 
 private:
-    GLFWwindow* m_window;
+    HWND m_hwnd;
+    HDC m_hdc;
+    HGLRC m_hglrc;
     RHIDeviceInfo m_deviceInfo;
     RHICapabilities m_capabilities;
     bool m_initialized;
     bool m_ownsWindow;
+    bool m_shouldClose;
 };
 
 } // namespace RHI
-} // namespace XCEngine
+} // namespace XCEngine

engine/include/XCEngine/RHI/OpenGL/OpenGLFence.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <cstdint>
 
 #include "../RHIFence.h"

engine/include/XCEngine/RHI/OpenGL/OpenGLPipelineState.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <cstdint>
 #include <string>
 

engine/include/XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h

@@ -1,6 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <cstdint>
 #include <vector>
 

engine/include/XCEngine/RHI/OpenGL/OpenGLSampler.h

@@ -1,7 +1,5 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
-
 #include "../RHISampler.h"
 #include "../RHITypes.h"
 

engine/include/XCEngine/RHI/OpenGL/OpenGLShader.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <GLFW/glfw3.h>
 #include <vector>
 
 #include "../RHIShader.h"

engine/include/XCEngine/RHI/OpenGL/OpenGLSwapChain.h

@@ -1,13 +1,18 @@
 #pragma once
 
-#include <GLFW/glfw3.h>
 #include <cstdint>
 
 #include "../RHISwapChain.h"
 
+struct HWND__;
+struct HDC__;
+
 namespace XCEngine {
 namespace RHI {
 
+using HWND = HWND__*;
+using HDC = HDC__*;
+
 enum class PresentMode {
     Immediate,
     VSync,
@@ -27,8 +32,8 @@ public:
     OpenGLSwapChain();
     ~OpenGLSwapChain() override;
 
-    bool Initialize(GLFWwindow* window, bool vsync = true);
-    bool Initialize(GLFWwindow* window, int width, int height, PresentMode mode = PresentMode::VSync);
+    bool Initialize(HWND window, bool vsync = true);
+    bool Initialize(HWND window, int width, int height, PresentMode mode = PresentMode::VSync);
     void Shutdown() override;
 
     void Present(uint32_t syncInterval = 1, uint32_t flags = 0) override;
@@ -45,7 +50,8 @@ public:
     int GetFramebufferWidth() const { return m_framebufferWidth; }
     int GetFramebufferHeight() const { return m_framebufferHeight; }
 
-    GLFWwindow* GetWindow() const { return m_window; }
+    HWND GetWindow() const { return m_hwnd; }
+    HDC GetDC() const { return m_hdc; }
 
     bool ShouldClose() const override;
     void SetShouldClose(bool shouldClose) override;
@@ -56,14 +62,16 @@ public:
     void* GetNativeHandle() override;
 
 private:
-    GLFWwindow* m_window;
+    HWND m_hwnd;
+    HDC m_hdc;
     int m_width;
     int m_height;
     int m_framebufferWidth;
     int m_framebufferHeight;
     bool m_vsync;
+    bool m_shouldClose;
     PresentMode m_presentMode;
 };
 
 } // namespace RHI
-} // namespace XCEngine
+} // namespace XCEngine

engine/include/XCEngine/RHI/OpenGL/OpenGLTexture.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <GLFW/glfw3.h>
 #include <vector>
 
 #include "../RHITexture.h"

engine/include/XCEngine/RHI/OpenGL/OpenGLVertexArray.h

@@ -1,7 +1,6 @@
 #pragma once
 
 #include <string>
-#include <GLFW/glfw3.h>
 #include <vector>
 
 namespace XCEngine {

engine/src/RHI/OpenGL/OpenGLBuffer.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLBuffer.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLCommandList.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLCommandList.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLDevice.cpp

@@ -1,4 +1,10 @@
-#define GLFW_INCLUDE_NONE
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+
+#include <stdio.h>
+#include <glad/glad.h>
+#include <windows.h>
+
 #include "XCEngine/RHI/OpenGL/OpenGLDevice.h"
 #include "XCEngine/RHI/OpenGL/OpenGLBuffer.h"
 #include "XCEngine/RHI/OpenGL/OpenGLTexture.h"
@@ -9,16 +15,20 @@
 #include "XCEngine/RHI/OpenGL/OpenGLCommandList.h"
 #include "XCEngine/RHI/OpenGL/OpenGLCommandQueue.h"
 #include "XCEngine/RHI/OpenGL/OpenGLSwapChain.h"
-#include <glad/glad.h>
-#include <GLFW/glfw3.h>
+
+static bool s_windowClassRegistered = false;
+static const wchar_t kWindowClassName[] = L"XCEngine_OpenGL_WindowClass";
 
 namespace XCEngine {
 namespace RHI {
 
 OpenGLDevice::OpenGLDevice()
-    : m_window(nullptr)
+    : m_hwnd(nullptr)
+    , m_hdc(nullptr)
+    , m_hglrc(nullptr)
     , m_initialized(false)
-    , m_ownsWindow(false) {
+    , m_ownsWindow(false)
+    , m_shouldClose(false) {
 }
 
 OpenGLDevice::~OpenGLDevice() {
@@ -31,7 +41,7 @@ bool OpenGLDevice::Initialize(const RHIDeviceDesc& desc) {
     }
 
     if (desc.windowHandle) {
-        return InitializeWithExistingWindow(static_cast<GLFWwindow*>(desc.windowHandle));
+        return InitializeWithExistingWindow(static_cast<HWND>(desc.windowHandle));
     }
 
     std::string titleStr = "XCEngine";
@@ -47,42 +57,121 @@ bool OpenGLDevice::CreateRenderWindow(int width, int height, const char* title,
         return true;
     }
 
-    static bool glfwInitialized = false;
-    if (!glfwInitialized) {
-        glfwInit();
-        glfwInitialized = true;
+    if (!s_windowClassRegistered) {
+        WNDCLASSEXW wc = {};
+        wc.cbSize = sizeof(WNDCLASSEXW);
+        wc.style = CS_HREDRAW | CS_VREDRAW;
+        wc.lpfnWndProc = DefWindowProcW;
+        wc.hInstance = GetModuleHandleW(nullptr);
+        wc.lpszClassName = kWindowClassName;
+        if (!RegisterClassExW(&wc)) {
+            return false;
+        }
+        s_windowClassRegistered = true;
     }
 
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
-    glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
-    glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
+    std::wstring titleW(title ? std::wstring(title, title + strlen(title)) : L"XCEngine");
+    
+    HWND hwnd = CreateWindowExW(
+        0,
+        kWindowClassName,
+        titleW.c_str(),
+        WS_OVERLAPPEDWINDOW,
+        CW_USEDEFAULT, CW_USEDEFAULT,
+        width, height,
+        nullptr,
+        nullptr,
+        GetModuleHandleW(nullptr),
+        nullptr
+    );
 
-    m_window = glfwCreateWindow(width, height, title, nullptr, nullptr);
-    if (!m_window) {
+    if (!hwnd) {
         return false;
     }
 
-    glfwSetWindowShouldClose(m_window, GLFW_FALSE);
-
+    m_hwnd = hwnd;
     m_ownsWindow = true;
-    return InitializeWithExistingWindow(m_window);
+
+    ShowWindow(m_hwnd, SW_SHOWNORMAL);
+    UpdateWindow(m_hwnd);
+
+    return InitializeWithExistingWindow(m_hwnd);
 }
 
-bool OpenGLDevice::InitializeWithExistingWindow(GLFWwindow* window) {
+bool OpenGLDevice::InitializeWithExistingWindow(HWND hwnd) {
     if (m_initialized) {
         return true;
     }
 
-    m_window = window;
-    if (!m_window) {
+    if (!hwnd) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: hwnd is null\n");
         return false;
     }
 
-    glfwMakeContextCurrent(m_window);
-
-    if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) {
+    m_hwnd = hwnd;
+    m_hdc = ::GetDC(m_hwnd);
+    if (!m_hdc) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: GetDC failed\n");
         return false;
     }
+    fprintf(stderr, "[OpenGLDevice] GetDC succeeded\n");
+
+    PIXELFORMATDESCRIPTOR pfd = {};
+    pfd.nSize = sizeof(PIXELFORMATDESCRIPTOR);
+    pfd.nVersion = 1;
+    pfd.dwFlags = PFD_DRAW_TO_WINDOW | PFD_SUPPORT_OPENGL | PFD_DOUBLEBUFFER;
+    pfd.iPixelType = PFD_TYPE_RGBA;
+    pfd.cColorBits = 32;
+    pfd.cDepthBits = 24;
+    pfd.cStencilBits = 8;
+    pfd.iLayerType = PFD_MAIN_PLANE;
+
+    int pixelFormat = ChoosePixelFormat(m_hdc, &pfd);
+    if (!pixelFormat) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: ChoosePixelFormat failed\n");
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hdc = nullptr;
+        return false;
+    }
+    fprintf(stderr, "[OpenGLDevice] ChoosePixelFormat succeeded\n");
+
+    if (!SetPixelFormat(m_hdc, pixelFormat, &pfd)) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: SetPixelFormat failed\n");
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hdc = nullptr;
+        return false;
+    }
+    fprintf(stderr, "[OpenGLDevice] SetPixelFormat succeeded\n");
+
+    m_hglrc = wglCreateContext(m_hdc);
+    if (!m_hglrc) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: wglCreateContext failed\n");
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hdc = nullptr;
+        return false;
+    }
+    fprintf(stderr, "[OpenGLDevice] wglCreateContext succeeded\n");
+
+    if (!wglMakeCurrent(m_hdc, m_hglrc)) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: wglMakeCurrent failed\n");
+        wglDeleteContext(m_hglrc);
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hglrc = nullptr;
+        m_hdc = nullptr;
+        return false;
+    }
+    fprintf(stderr, "[OpenGLDevice] wglMakeCurrent succeeded\n");
+
+    if (!gladLoadGL()) {
+        fprintf(stderr, "[OpenGLDevice] ERROR: gladLoadGL failed\n");
+        wglMakeCurrent(nullptr, nullptr);
+        wglDeleteContext(m_hglrc);
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hglrc = nullptr;
+        m_hdc = nullptr;
+        return false;
+    }
+    fprintf(stderr, "[OpenGLDevice] gladLoadGL succeeded\n");
 
     const char* vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
     const char* renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
@@ -135,33 +224,55 @@ bool OpenGLDevice::InitializeWithExistingWindow(GLFWwindow* window) {
 }
 
 void OpenGLDevice::Shutdown() {
-    if (m_ownsWindow && m_window) {
-        glfwDestroyWindow(m_window);
+    if (m_hglrc) {
+        wglMakeCurrent(nullptr, nullptr);
+        wglDeleteContext(m_hglrc);
+        m_hglrc = nullptr;
     }
-    m_window = nullptr;
+
+    if (m_hdc && m_hwnd) {
+        ReleaseDC(m_hwnd, m_hdc);
+        m_hdc = nullptr;
+    }
+
+    if (m_ownsWindow && m_hwnd) {
+        DestroyWindow(m_hwnd);
+        m_hwnd = nullptr;
+    }
+
     m_initialized = false;
     m_ownsWindow = false;
+    m_shouldClose = false;
 }
 
 void OpenGLDevice::SwapBuffers() {
-    if (m_window) {
-        glfwSwapBuffers(m_window);
+    if (m_hdc) {
+        ::SwapBuffers(m_hdc);
     }
 }
 
 bool OpenGLDevice::PollEvents() {
-    glfwPollEvents();
-    return !glfwWindowShouldClose(m_window);
+    MSG msg;
+    while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) {
+        if (msg.message == WM_QUIT) {
+            m_shouldClose = true;
+            return false;
+        }
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+    }
+    return !m_shouldClose;
 }
 
 void OpenGLDevice::SetShouldClose(bool shouldClose) {
-    if (m_window) {
-        glfwSetWindowShouldClose(m_window, shouldClose ? GLFW_TRUE : GLFW_FALSE);
+    m_shouldClose = shouldClose;
+    if (m_hwnd && shouldClose) {
+        PostMessageW(m_hwnd, WM_CLOSE, 0, 0);
     }
 }
 
 bool OpenGLDevice::ShouldClose() const {
-    return m_window && glfwWindowShouldClose(m_window) == GLFW_TRUE;
+    return m_shouldClose;
 }
 
 RHIBuffer* OpenGLDevice::CreateBuffer(const BufferDesc& desc) {
@@ -169,10 +280,10 @@ RHIBuffer* OpenGLDevice::CreateBuffer(const BufferDesc& desc) {
     OpenGLBufferType bufferType = OpenGLBufferType::Vertex;
     
     switch (desc.bufferType) {
-        case 1: // Index buffer
+        case 1:
             bufferType = OpenGLBufferType::Index;
             break;
-        case 2: // Constant buffer
+        case 2:
             bufferType = OpenGLBufferType::Uniform;
             break;
         default:
@@ -210,8 +321,8 @@ RHITexture* OpenGLDevice::CreateTexture(const TextureDesc& desc) {
 
 RHISwapChain* OpenGLDevice::CreateSwapChain(const SwapChainDesc& desc) {
     auto* swapChain = new OpenGLSwapChain();
-    if (m_window) {
-        swapChain->Initialize(m_window, desc.width, desc.height);
+    if (m_hwnd) {
+        swapChain->Initialize(m_hwnd, desc.width, desc.height);
     }
     return swapChain;
 }
@@ -272,4 +383,4 @@ void* OpenGLDevice::GetNativeHandle() const {
 }
 
 } // namespace RHI
-} // namespace XCEngine
+} // namespace XCEngine

engine/src/RHI/OpenGL/OpenGLFence.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLFence.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLSampler.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLSampler.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {

engine/src/RHI/OpenGL/OpenGLShader.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLShader.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 #include <fstream>
 #include <sstream>
 #include <iostream>

engine/src/RHI/OpenGL/OpenGLSwapChain.cpp

@@ -1,28 +1,26 @@
-#define GLFW_INCLUDE_NONE
-#include "XCEngine/RHI/OpenGL/OpenGLSwapChain.h"
-#include <GLFW/glfw3.h>
+#define WIN32_LEAN_AND_MEAN
+#define NOMINMAX
+
 #include <glad/glad.h>
+#include <windows.h>
+
+#include "XCEngine/RHI/OpenGL/OpenGLSwapChain.h"
+
+typedef void (APIENTRY* PFNWGLSWAPINTERVALEXTPROC)(int);
+static PFNWGLSWAPINTERVALEXTPROC wglSwapIntervalEXT = nullptr;
 
 namespace XCEngine {
 namespace RHI {
 
-static int ToGLFWPresentMode(PresentMode mode) {
-    switch (mode) {
-        case PresentMode::Immediate: return 0;
-        case PresentMode::VSync: return 1;
-        case PresentMode::Mailbox: return -1;
-        case PresentMode::Fifo: return 1;
-        default: return 1;
-    }
-}
-
 OpenGLSwapChain::OpenGLSwapChain() 
-    : m_window(nullptr)
+    : m_hwnd(nullptr)
+    , m_hdc(nullptr)
     , m_width(0)
     , m_height(0)
     , m_framebufferWidth(0)
     , m_framebufferHeight(0)
     , m_vsync(true)
+    , m_shouldClose(false)
     , m_presentMode(PresentMode::VSync) {
 }
 
@@ -30,57 +28,73 @@ OpenGLSwapChain::~OpenGLSwapChain() {
     Shutdown();
 }
 
-bool OpenGLSwapChain::Initialize(GLFWwindow* window, bool vsync) {
-    m_window = window;
+bool OpenGLSwapChain::Initialize(HWND window, bool vsync) {
+    m_hwnd = window;
+    m_hdc = ::GetDC(m_hwnd);
     m_vsync = vsync;
     m_presentMode = vsync ? PresentMode::VSync : PresentMode::Immediate;
+    m_shouldClose = false;
 
-    int w, h;
-    glfwGetFramebufferSize(window, &w, &h);
-    m_framebufferWidth = w;
-    m_framebufferHeight = h;
+    if (!wglSwapIntervalEXT) {
+        wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
+    }
+    if (wglSwapIntervalEXT) {
+        wglSwapIntervalEXT(vsync ? 1 : 0);
+    }
 
-    glfwGetWindowSize(window, &w, &h);
-    m_width = w;
-    m_height = h;
-
-    glfwSwapInterval(m_vsync ? 1 : 0);
+    RECT rect;
+    ::GetClientRect(m_hwnd, &rect);
+    m_width = rect.right - rect.left;
+    m_height = rect.bottom - rect.top;
+    m_framebufferWidth = m_width;
+    m_framebufferHeight = m_height;
 
     return true;
 }
 
-bool OpenGLSwapChain::Initialize(GLFWwindow* window, int width, int height, PresentMode mode) {
-    m_window = window;
+bool OpenGLSwapChain::Initialize(HWND window, int width, int height, PresentMode mode) {
+    m_hwnd = window;
+    m_hdc = ::GetDC(m_hwnd);
     m_width = width;
     m_height = height;
     m_presentMode = mode;
     m_vsync = (mode == PresentMode::VSync || mode == PresentMode::Fifo);
+    m_shouldClose = false;
 
-    glfwSetWindowSize(window, width, height);
+    if (!wglSwapIntervalEXT) {
+        wglSwapIntervalEXT = (PFNWGLSWAPINTERVALEXTPROC)wglGetProcAddress("wglSwapIntervalEXT");
+    }
+    if (wglSwapIntervalEXT) {
+        wglSwapIntervalEXT(m_vsync ? 1 : 0);
+    }
 
-    int w, h;
-    glfwGetFramebufferSize(window, &w, &h);
-    m_framebufferWidth = w;
-    m_framebufferHeight = h;
+    ::SetWindowPos(m_hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
 
-    glfwSwapInterval(m_vsync ? 1 : 0);
+    m_framebufferWidth = width;
+    m_framebufferHeight = height;
 
     return true;
 }
 
 void OpenGLSwapChain::Shutdown() {
-    m_window = nullptr;
+    if (m_hdc && m_hwnd) {
+        ::ReleaseDC(m_hwnd, m_hdc);
+        m_hdc = nullptr;
+    }
+    m_hwnd = nullptr;
 }
 
 void OpenGLSwapChain::SwapBuffers() {
-    if (m_window) {
-        glfwSwapBuffers(m_window);
+    if (m_hdc) {
+        ::SwapBuffers(m_hdc);
     }
 }
 
 void OpenGLSwapChain::SetVSync(bool enabled) {
     m_vsync = enabled;
-    glfwSwapInterval(enabled ? 1 : 0);
+    if (wglSwapIntervalEXT) {
+        wglSwapIntervalEXT(enabled ? 1 : 0);
+    }
 }
 
 void OpenGLSwapChain::SetFramebufferSize(int width, int height) {
@@ -89,33 +103,42 @@ void OpenGLSwapChain::SetFramebufferSize(int width, int height) {
 }
 
 bool OpenGLSwapChain::ShouldClose() const {
-    return m_window && glfwWindowShouldClose(m_window);
+    return m_shouldClose;
 }
 
 void OpenGLSwapChain::SetShouldClose(bool shouldClose) {
-    if (m_window) {
-        glfwSetWindowShouldClose(m_window, shouldClose ? GLFW_TRUE : GLFW_FALSE);
+    m_shouldClose = shouldClose;
+    if (m_hwnd && shouldClose) {
+        PostMessageW(m_hwnd, WM_CLOSE, 0, 0);
     }
 }
 
 void OpenGLSwapChain::PollEvents() {
-    glfwPollEvents();
+    MSG msg;
+    while (PeekMessageW(&msg, nullptr, 0, 0, PM_REMOVE)) {
+        if (msg.message == WM_QUIT) {
+            m_shouldClose = true;
+            break;
+        }
+        TranslateMessage(&msg);
+        DispatchMessageW(&msg);
+    }
 }
 
 void OpenGLSwapChain::Present(uint32_t syncInterval, uint32_t flags) {
-    if (m_window) {
-        glfwSwapBuffers(m_window);
+    if (m_hdc) {
+        ::SwapBuffers(m_hdc);
     }
 }
 
 void OpenGLSwapChain::Resize(uint32_t width, uint32_t height) {
     m_width = width;
     m_height = height;
-    glfwSetWindowSize(m_window, width, height);
-    int w, h;
-    glfwGetFramebufferSize(m_window, &w, &h);
-    m_framebufferWidth = w;
-    m_framebufferHeight = h;
+    if (m_hwnd) {
+        ::SetWindowPos(m_hwnd, nullptr, 0, 0, width, height, SWP_NOMOVE | SWP_NOZORDER);
+    }
+    m_framebufferWidth = width;
+    m_framebufferHeight = height;
 }
 
 void OpenGLSwapChain::SetFullscreen(bool fullscreen) {
@@ -138,4 +161,4 @@ void* OpenGLSwapChain::GetNativeHandle() {
 }
 
 } // namespace RHI
-} // namespace XCEngine
+} // namespace XCEngine

engine/src/RHI/OpenGL/OpenGLTexture.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLTexture.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 #include <stb_image.h>
 #include <iostream>
 

engine/src/RHI/OpenGL/OpenGLVertexArray.cpp

@@ -1,7 +1,5 @@
-#define GLFW_INCLUDE_NONE
 #include "XCEngine/RHI/OpenGL/OpenGLVertexArray.h"
 #include <glad/glad.h>
-#include <GLFW/glfw3.h>
 
 namespace XCEngine {
 namespace RHI {