diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLBuffer.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLBuffer.h index 2da6c3e6..bcd22f18 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLBuffer.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLBuffer.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include "../RHIBuffer.h" diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLCommandList.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLCommandList.h index 6d62c676..ad4e4a3f 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLCommandList.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLCommandList.h @@ -1,6 +1,5 @@ #pragma once -#include #include #include diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h index e1f8fb86..83b9a869 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h @@ -1,6 +1,5 @@ #pragma once -#include #include namespace XCEngine { diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h index 17195659..91fef9d0 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLDevice.h @@ -1,14 +1,21 @@ #pragma once #include -#include #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 \ No newline at end of file diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLFence.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLFence.h index c1a945cd..a8fa380a 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLFence.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLFence.h @@ -1,6 +1,5 @@ #pragma once -#include #include #include "../RHIFence.h" diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLPipelineState.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLPipelineState.h index 1a9c59a0..e3affb6a 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLPipelineState.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLPipelineState.h @@ -1,6 +1,5 @@ #pragma once -#include #include #include diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h index cd8612e5..ee17683c 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h @@ -1,6 +1,5 @@ #pragma once -#include #include #include diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLSampler.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLSampler.h index 006cd85b..9473c1e5 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLSampler.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLSampler.h @@ -1,7 +1,5 @@ #pragma once -#include - #include "../RHISampler.h" #include "../RHITypes.h" diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLShader.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLShader.h index ef6d77fe..4c8a6838 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLShader.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLShader.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include "../RHIShader.h" diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLSwapChain.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLSwapChain.h index c3c70a2e..d28ab8ef 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLSwapChain.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLSwapChain.h @@ -1,13 +1,18 @@ #pragma once -#include #include #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 \ No newline at end of file diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLTexture.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLTexture.h index 8dd32786..7d8ddf08 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLTexture.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLTexture.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include #include "../RHITexture.h" diff --git a/engine/include/XCEngine/RHI/OpenGL/OpenGLVertexArray.h b/engine/include/XCEngine/RHI/OpenGL/OpenGLVertexArray.h index 333a51e2..af976f90 100644 --- a/engine/include/XCEngine/RHI/OpenGL/OpenGLVertexArray.h +++ b/engine/include/XCEngine/RHI/OpenGL/OpenGLVertexArray.h @@ -1,7 +1,6 @@ #pragma once #include -#include #include namespace XCEngine { diff --git a/engine/src/RHI/OpenGL/OpenGLBuffer.cpp b/engine/src/RHI/OpenGL/OpenGLBuffer.cpp index d05b2c8d..dc84c7ab 100644 --- a/engine/src/RHI/OpenGL/OpenGLBuffer.cpp +++ b/engine/src/RHI/OpenGL/OpenGLBuffer.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLBuffer.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLCommandList.cpp b/engine/src/RHI/OpenGL/OpenGLCommandList.cpp index ecf446e5..c824e000 100644 --- a/engine/src/RHI/OpenGL/OpenGLCommandList.cpp +++ b/engine/src/RHI/OpenGL/OpenGLCommandList.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLCommandList.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp b/engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp index 259004d6..a127d7da 100644 --- a/engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp +++ b/engine/src/RHI/OpenGL/OpenGLDepthStencilView.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLDepthStencilView.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLDevice.cpp b/engine/src/RHI/OpenGL/OpenGLDevice.cpp index ac0b2bdd..996bf47c 100644 --- a/engine/src/RHI/OpenGL/OpenGLDevice.cpp +++ b/engine/src/RHI/OpenGL/OpenGLDevice.cpp @@ -1,4 +1,10 @@ -#define GLFW_INCLUDE_NONE +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX + +#include +#include +#include + #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 -#include + +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(desc.windowHandle)); + return InitializeWithExistingWindow(static_cast(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(glGetString(GL_VENDOR)); const char* renderer = reinterpret_cast(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 \ No newline at end of file diff --git a/engine/src/RHI/OpenGL/OpenGLFence.cpp b/engine/src/RHI/OpenGL/OpenGLFence.cpp index e7492e86..45a09ff1 100644 --- a/engine/src/RHI/OpenGL/OpenGLFence.cpp +++ b/engine/src/RHI/OpenGL/OpenGLFence.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLFence.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp b/engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp index e364dd03..0b8047bd 100644 --- a/engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp +++ b/engine/src/RHI/OpenGL/OpenGLRenderTargetView.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLRenderTargetView.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLSampler.cpp b/engine/src/RHI/OpenGL/OpenGLSampler.cpp index 5c761e7d..e41e4006 100644 --- a/engine/src/RHI/OpenGL/OpenGLSampler.cpp +++ b/engine/src/RHI/OpenGL/OpenGLSampler.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLSampler.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/engine/src/RHI/OpenGL/OpenGLShader.cpp b/engine/src/RHI/OpenGL/OpenGLShader.cpp index 93d78a0e..14c0428b 100644 --- a/engine/src/RHI/OpenGL/OpenGLShader.cpp +++ b/engine/src/RHI/OpenGL/OpenGLShader.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLShader.h" #include -#include #include #include #include diff --git a/engine/src/RHI/OpenGL/OpenGLSwapChain.cpp b/engine/src/RHI/OpenGL/OpenGLSwapChain.cpp index a43f6629..0fcf04d4 100644 --- a/engine/src/RHI/OpenGL/OpenGLSwapChain.cpp +++ b/engine/src/RHI/OpenGL/OpenGLSwapChain.cpp @@ -1,28 +1,26 @@ -#define GLFW_INCLUDE_NONE -#include "XCEngine/RHI/OpenGL/OpenGLSwapChain.h" -#include +#define WIN32_LEAN_AND_MEAN +#define NOMINMAX + #include +#include + +#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 \ No newline at end of file diff --git a/engine/src/RHI/OpenGL/OpenGLTexture.cpp b/engine/src/RHI/OpenGL/OpenGLTexture.cpp index 9b934fdc..64183c48 100644 --- a/engine/src/RHI/OpenGL/OpenGLTexture.cpp +++ b/engine/src/RHI/OpenGL/OpenGLTexture.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLTexture.h" #include -#include #include #include diff --git a/engine/src/RHI/OpenGL/OpenGLVertexArray.cpp b/engine/src/RHI/OpenGL/OpenGLVertexArray.cpp index 240ea813..a344bb7b 100644 --- a/engine/src/RHI/OpenGL/OpenGLVertexArray.cpp +++ b/engine/src/RHI/OpenGL/OpenGLVertexArray.cpp @@ -1,7 +1,5 @@ -#define GLFW_INCLUDE_NONE #include "XCEngine/RHI/OpenGL/OpenGLVertexArray.h" #include -#include namespace XCEngine { namespace RHI { diff --git a/tests/RHI/OpenGL/integration/CMakeLists.txt b/tests/RHI/OpenGL/integration/CMakeLists.txt index fdc7dc8e..0319f37f 100644 --- a/tests/RHI/OpenGL/integration/CMakeLists.txt +++ b/tests/RHI/OpenGL/integration/CMakeLists.txt @@ -24,7 +24,6 @@ target_include_directories(OpenGL_Minimal PRIVATE target_link_libraries(OpenGL_Minimal PRIVATE opengl32 - ${PACKAGE_DIR}/lib/glfw3.lib XCEngine ) diff --git a/tests/RHI/OpenGL/integration/minimal/main.cpp b/tests/RHI/OpenGL/integration/minimal/main.cpp index 63c823c3..83bfa696 100644 --- a/tests/RHI/OpenGL/integration/minimal/main.cpp +++ b/tests/RHI/OpenGL/integration/minimal/main.cpp @@ -1,23 +1,23 @@ -#include -#include #include -#include #include +#include +#include + +#include "XCEngine/RHI/OpenGL/OpenGLDevice.h" +#include "XCEngine/RHI/OpenGL/OpenGLSwapChain.h" #include "XCEngine/Debug/Logger.h" #include "XCEngine/Debug/ConsoleLogSink.h" #include "XCEngine/Containers/String.h" #pragma comment(lib, "opengl32.lib") +using namespace XCEngine::RHI; using namespace XCEngine::Debug; using namespace XCEngine::Containers; static const int gWidth = 1280; static const int gHeight = 720; -static HWND gHWND = nullptr; -static HDC gHDC = nullptr; -static HGLRC gHGLRC = nullptr; void Log(const char* format, ...) { char buffer[1024]; @@ -28,6 +28,38 @@ void Log(const char* format, ...) { Logger::Get().Debug(LogCategory::Rendering, String(buffer)); } +void SaveScreenshotPPM(const char* filename, int width, int height) { + unsigned char* pixels = (unsigned char*)malloc(width * height * 3); + if (!pixels) { + Log("[ERROR] Failed to allocate pixel buffer"); + return; + } + + glPixelStorei(GL_PACK_ALIGNMENT, 1); + glReadPixels(0, 0, width, height, GL_RGB, GL_UNSIGNED_BYTE, pixels); + + FILE* f = fopen(filename, "wb"); + if (!f) { + Log("[ERROR] Failed to open file for screenshot: %s", filename); + free(pixels); + return; + } + + fprintf(f, "P6\n%d %d\n255\n", width, height); + + unsigned char* row = (unsigned char*)malloc(width * 3); + for (int y = height - 1; y >= 0; y--) { + memcpy(row, pixels + y * width * 3, width * 3); + fwrite(row, 1, width * 3, f); + } + + free(row); + free(pixels); + fclose(f); + + Log("[INFO] Screenshot saved to %s", filename); +} + LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { switch (msg) { case WM_CLOSE: @@ -37,109 +69,6 @@ LRESULT CALLBACK WindowProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam) { return DefWindowProc(hwnd, msg, wParam, lParam); } -bool InitOpenGL() { - gHDC = GetDC(gHWND); - if (!gHDC) { - Log("[ERROR] Failed to get DC"); - return false; - } - - 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(gHDC, &pfd); - if (!pixelFormat) { - Log("[ERROR] Failed to choose pixel format"); - return false; - } - - if (!SetPixelFormat(gHDC, pixelFormat, &pfd)) { - Log("[ERROR] Failed to set pixel format"); - return false; - } - - gHGLRC = wglCreateContext(gHDC); - if (!gHGLRC) { - Log("[ERROR] Failed to create GL context"); - return false; - } - - if (!wglMakeCurrent(gHDC, gHGLRC)) { - Log("[ERROR] Failed to make GL context current"); - return false; - } - - if (!gladLoadGL()) { - Log("[ERROR] Failed to load OpenGL functions"); - return false; - } - - Log("[INFO] OpenGL initialized: %s", glGetString(GL_RENDERER)); - Log("[INFO] OpenGL Version: %s", glGetString(GL_VERSION)); - - glViewport(0, 0, gWidth, gHeight); - glEnable(GL_DEPTH_TEST); - glDepthFunc(GL_LEQUAL); - - return true; -} - -void ShutdownOpenGL() { - if (gHGLRC) { - wglDeleteContext(gHGLRC); - gHGLRC = nullptr; - } - if (gHDC) { - ReleaseDC(gHWND, gHDC); - gHDC = nullptr; - } -} - -void SaveScreenshotPPM(const char* filename) { - unsigned char* pixels = (unsigned char*)malloc(gWidth * gHeight * 3); - if (!pixels) { - Log("[ERROR] Failed to allocate pixel buffer"); - return; - } - - glPixelStorei(GL_PACK_ALIGNMENT, 1); - glReadPixels(0, 0, gWidth, gHeight, GL_RGB, GL_UNSIGNED_BYTE, pixels); - - FILE* f = fopen(filename, "wb"); - if (!f) { - Log("[ERROR] Failed to open file for screenshot: %s", filename); - free(pixels); - return; - } - - fprintf(f, "P6\n%d %d\n255\n", gWidth, gHeight); - - unsigned char* row = (unsigned char*)malloc(gWidth * 3); - for (int y = gHeight - 1; y >= 0; y--) { - memcpy(row, pixels + y * gWidth * 3, gWidth * 3); - fwrite(row, 1, gWidth * 3, f); - } - - free(row); - free(pixels); - fclose(f); - - Log("[INFO] Screenshot saved to %s", filename); -} - -void RenderFrame() { - glClearColor(1.0f, 0.0f, 0.0f, 1.0f); - glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); - SwapBuffers(gHDC); -} - int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine, int nShowCmd) { Logger::Get().Initialize(); Logger::Get().AddSink(std::make_unique()); @@ -147,63 +76,86 @@ int WINAPI WinMain(HINSTANCE hInstance, HINSTANCE hPrevInstance, LPSTR lpCmdLine Log("[INFO] OpenGL Integration Test Starting"); - WNDCLASSEX wc = {}; - wc.cbSize = sizeof(WNDCLASSEX); + WNDCLASSEXW wc = {}; + wc.cbSize = sizeof(WNDCLASSEXW); wc.style = CS_HREDRAW | CS_VREDRAW; wc.lpfnWndProc = WindowProc; wc.hInstance = hInstance; - wc.lpszClassName = L"OpenGLTest"; + wc.lpszClassName = L"XCEngine_OpenGL_Test"; - if (!RegisterClassEx(&wc)) { - MessageBox(NULL, L"Failed to register window class", L"Error", MB_OK); + if (!RegisterClassExW(&wc)) { + Log("[ERROR] Failed to register window class"); return -1; } RECT rect = { 0, 0, gWidth, gHeight }; AdjustWindowRect(&rect, WS_OVERLAPPEDWINDOW, FALSE); - gHWND = CreateWindowEx(0, L"OpenGLTest", L"OpenGL Integration Test", - WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, + HWND hwnd = CreateWindowExW( + 0, + L"XCEngine_OpenGL_Test", + L"OpenGL Integration Test", + WS_OVERLAPPEDWINDOW, + CW_USEDEFAULT, CW_USEDEFAULT, rect.right - rect.left, rect.bottom - rect.top, - NULL, NULL, hInstance, NULL); + NULL, NULL, hInstance, NULL + ); - if (!gHWND) { - MessageBox(NULL, L"Failed to create window", L"Error", MB_OK); + RECT clientRect; + GetClientRect(hwnd, &clientRect); + fprintf(stderr, "[minimal] Window client area: %ldx%ld\n", clientRect.right, clientRect.bottom); + + if (!hwnd) { + Log("[ERROR] Failed to create window"); return -1; } - if (!InitOpenGL()) { - MessageBox(NULL, L"Failed to initialize OpenGL", L"Error", MB_OK); + OpenGLDevice device; + fprintf(stderr, "[minimal] About to call InitializeWithExistingWindow\n"); + if (!device.InitializeWithExistingWindow(hwnd)) { + fprintf(stderr, "[minimal] InitializeWithExistingWindow returned false\n"); + Log("[ERROR] Failed to initialize OpenGL device"); return -1; } + fprintf(stderr, "[minimal] InitializeWithExistingWindow succeeded\n"); - ShowWindow(gHWND, nShowCmd); - UpdateWindow(gHWND); + ShowWindow(hwnd, nShowCmd); + UpdateWindow(hwnd); + + Log("[INFO] OpenGL Device: %S", device.GetDeviceInfo().renderer.c_str()); + Log("[INFO] OpenGL Version: %S", device.GetDeviceInfo().version.c_str()); + + OpenGLSwapChain swapChain; + swapChain.Initialize(hwnd, gWidth, gHeight); MSG msg = {}; int frameCount = 0; const int targetFrameCount = 30; while (true) { - if (PeekMessage(&msg, NULL, 0, 0, PM_REMOVE)) { + if (PeekMessageW(&msg, NULL, 0, 0, PM_REMOVE)) { if (msg.message == WM_QUIT) { break; } TranslateMessage(&msg); - DispatchMessage(&msg); + DispatchMessageW(&msg); } else { - RenderFrame(); + glViewport(0, 0, gWidth, gHeight); + glClearColor(1.0f, 0.0f, 0.0f, 1.0f); + glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); + swapChain.Present(0, 0); frameCount++; if (frameCount >= targetFrameCount) { Log("[INFO] Reached target frame count %d - taking screenshot!", targetFrameCount); - SaveScreenshotPPM("minimal.ppm"); + SaveScreenshotPPM("minimal.ppm", gWidth, gHeight); break; } } } - ShutdownOpenGL(); + swapChain.Shutdown(); + device.Shutdown(); Logger::Get().Shutdown(); Log("[INFO] OpenGL Integration Test Finished"); diff --git a/tests/RHI/OpenGL/unit/CMakeLists.txt b/tests/RHI/OpenGL/unit/CMakeLists.txt index 958273d8..dbf30d5c 100644 --- a/tests/RHI/OpenGL/unit/CMakeLists.txt +++ b/tests/RHI/OpenGL/unit/CMakeLists.txt @@ -8,8 +8,6 @@ include_directories(${CMAKE_SOURCE_DIR}/tests/OpenGL/package/include/) include_directories(${PROJECT_ROOT_DIR}/engine/include) include_directories(${PROJECT_ROOT_DIR}/engine/src) -link_directories(${CMAKE_SOURCE_DIR}/tests/OpenGL/package/lib/) - find_package(GTest REQUIRED) set(TEST_SOURCES @@ -33,7 +31,6 @@ add_executable(opengl_engine_tests ${TEST_SOURCES}) target_link_libraries(opengl_engine_tests PRIVATE opengl32 - glfw3 XCEngine GTest::gtest GTest::gtest_main diff --git a/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.cpp b/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.cpp index c353085d..e4d6e76d 100644 --- a/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.cpp +++ b/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.cpp @@ -1,45 +1,107 @@ +#include #include "OpenGLTestFixture.h" using namespace XCEngine::RHI; -static bool s_glfwInitialized = false; -static bool s_gladInitialized = false; +static bool s_windowClassRegistered = false; +static const wchar_t kWindowClassName[] = L"XCEngine_Test_WindowClass"; void OpenGLTestFixture::SetUp() { - if (!s_glfwInitialized) { - if (!glfwInit()) { - GTEST_SKIP() << "Failed to initialize GLFW"; + 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)) { + GTEST_SKIP() << "Failed to register window class"; return; } - - glfwWindowHint(GLFW_VISIBLE, GLFW_FALSE); - glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 4); - glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 6); - glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE); - - s_glfwInitialized = true; + s_windowClassRegistered = true; } - m_window = glfwCreateWindow(640, 480, "OpenGL Tests", nullptr, nullptr); - if (!m_window) { - GTEST_SKIP() << "Failed to create GLFW window"; + m_hwnd = CreateWindowExW( + 0, + kWindowClassName, + L"OpenGL Tests", + WS_POPUP, + 0, 0, + 640, 480, + nullptr, + nullptr, + GetModuleHandleW(nullptr), + nullptr + ); + + if (!m_hwnd) { + GTEST_SKIP() << "Failed to create window"; return; } - glfwMakeContextCurrent(m_window); + ShowWindow(m_hwnd, SW_HIDE); + m_hdc = GetDC(m_hwnd); - if (!s_gladInitialized) { - if (!gladLoadGLLoader((GLADloadproc)glfwGetProcAddress)) { - GTEST_SKIP() << "Failed to initialize GLAD"; - glfwDestroyWindow(m_window); - m_window = nullptr; - return; - } - s_gladInitialized = true; + 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) { + ReleaseDC(m_hwnd, m_hdc); + DestroyWindow(m_hwnd); + m_hwnd = nullptr; + GTEST_SKIP() << "Failed to choose pixel format"; + return; + } + + if (!SetPixelFormat(m_hdc, pixelFormat, &pfd)) { + ReleaseDC(m_hwnd, m_hdc); + DestroyWindow(m_hwnd); + m_hwnd = nullptr; + GTEST_SKIP() << "Failed to set pixel format"; + return; + } + + m_hglrc = wglCreateContext(m_hdc); + if (!m_hglrc) { + ReleaseDC(m_hwnd, m_hdc); + DestroyWindow(m_hwnd); + m_hwnd = nullptr; + GTEST_SKIP() << "Failed to create GL context"; + return; + } + + if (!wglMakeCurrent(m_hdc, m_hglrc)) { + wglDeleteContext(m_hglrc); + ReleaseDC(m_hwnd, m_hdc); + DestroyWindow(m_hwnd); + m_hglrc = nullptr; + m_hwnd = nullptr; + GTEST_SKIP() << "Failed to make GL context current"; + return; + } + + if (!gladLoadGLLoader((GLADloadproc)wglGetProcAddress)) { + wglMakeCurrent(nullptr, nullptr); + wglDeleteContext(m_hglrc); + ReleaseDC(m_hwnd, m_hdc); + DestroyWindow(m_hwnd); + m_hglrc = nullptr; + m_hwnd = nullptr; + GTEST_SKIP() << "Failed to load OpenGL functions"; + return; } m_device = new OpenGLDevice(); - m_device->CreateRenderWindow(640, 480, "Test Window", false); + m_device->InitializeWithExistingWindow(m_hwnd); + m_ownsWindow = true; ClearGLErrors(); } @@ -52,20 +114,31 @@ void OpenGLTestFixture::TearDown() { m_device = nullptr; } - if (m_window) { - glfwDestroyWindow(m_window); - m_window = nullptr; + if (m_hglrc) { + wglMakeCurrent(nullptr, nullptr); + wglDeleteContext(m_hglrc); + m_hglrc = 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; } } void OpenGLTestFixture::MakeContextCurrent() { - if (m_window) { - glfwMakeContextCurrent(m_window); + if (m_hdc && m_hglrc) { + wglMakeCurrent(m_hdc, m_hglrc); } } void OpenGLTestFixture::DoneContextCurrent() { - glfwMakeContextCurrent(nullptr); + wglMakeCurrent(nullptr, nullptr); } void OpenGLTestFixture::ClearGLErrors() { diff --git a/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.h b/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.h index 30f4e9da..bfc7efd7 100644 --- a/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.h +++ b/tests/RHI/OpenGL/unit/fixtures/OpenGLTestFixture.h @@ -1,7 +1,7 @@ #pragma once +#include #include -#include #include #include "XCEngine/RHI/OpenGL/OpenGLDevice.h" @@ -14,7 +14,9 @@ protected: void SetUp() override; void TearDown() override; - GLFWwindow* GetWindow() { return m_window; } + HWND GetWindow() { return m_hwnd; } + HDC GetDC() { return m_hdc; } + HGLRC GetContext() { return m_hglrc; } void MakeContextCurrent(); void DoneContextCurrent(); @@ -24,8 +26,11 @@ protected: void ResetGLState(); private: - GLFWwindow* m_window = nullptr; + HWND m_hwnd = nullptr; + HDC m_hdc = nullptr; + HGLRC m_hglrc = nullptr; OpenGLDevice* m_device = nullptr; + bool m_ownsWindow = false; }; } // namespace RHI diff --git a/tests/RHI/OpenGL/unit/test_device.cpp b/tests/RHI/OpenGL/unit/test_device.cpp index 2cc52f90..4b593113 100644 --- a/tests/RHI/OpenGL/unit/test_device.cpp +++ b/tests/RHI/OpenGL/unit/test_device.cpp @@ -23,7 +23,7 @@ TEST_F(OpenGLTestFixture, Device_CreateRenderWindow_DebugMode) { TEST_F(OpenGLTestFixture, Device_InitializeWithExistingWindow) { OpenGLDevice device; - GLFWwindow* existingWindow = GetWindow(); + HWND existingWindow = GetWindow(); bool result = device.InitializeWithExistingWindow(existingWindow);