c++ GLFW类多窗口

stszievb  于 2023-06-25  发布在  其他
关注(0)|答案(2)|浏览(270)

我是OpenGL的新手，目前我正在为OpenGL学习做我的测试OpenGL项目。而这个项目的一个组件是WindowManager。我已经尝试添加多个窗口创建支持，但它不工作的方式，我想要的。
当我启动我的应用程序时，两个窗口（让我们称之为A-FIRST_WINDOW，B-SECOND_WINDOW）同时被创建，但当我关闭B窗口时，我的应用程序仍然工作，这很好，因为A窗口仍然可用，我可以使用它，当我关闭A窗口时，我的应用程序被关闭。但是如果我先关闭A窗口，我的B窗口也会关闭，应用程序也会完成。
注：A窗口-第一个创建B窗口-第二个创建
密码...
WindowManager.hpp

  1. #include <GLFW/glfw3.h>
  3. #define DEFAULT_WIDTH 800
  4. #define DEFAULT_HEIGHT 600
  5. #define DEFAULT_TITLE "Soul Byte Engine Window"
  7. namespace SoulByteEngineCore
  8. {
  9.     namespace WindowManager
  10.     {
  11.         class Window
  12.         {
  13.         public:
  14.             Window(unsigned int width=DEFAULT_WIDTH, unsigned int height=DEFAULT_HEIGHT, const char *title = DEFAULT_TITLE);
  15.         public:
  16.             void Clear(float x_pos, float y_pos, float z_pos);
  17.         public:
  18.             unsigned int GetWidth();
  19.             unsigned int GetHeight();
  20.         public:
  21.             static bool Init();
  22.         public:
  23.             void ShowWindowData();
  24.         public:
  25.             const char* GetTitle();
  26.         public:
  27.             bool SetLogging();
  28.         public:
  29.             void onUpdate();
  30.         public:
  31.             bool ShouldClose();
  32.         public:
  33.             void Destroy();
  34.         private:
  35.             bool CreateWindow();
  36.         private:
  37.             void Update();
  38.         private:
  39.             unsigned int m_windowWidth = DEFAULT_WIDTH;
  40.             unsigned int m_windowHeight = DEFAULT_HEIGHT;
  41.         private:
  42.             const char* m_windowTitle = DEFAULT_TITLE;
  43.         private:
  44.             unsigned int OpenGLMajorVersion = 3;
  45.             unsigned int OpenGLMinorVersion = 3;
  46.         private:
  47.             GLFWwindow* m_window_handle = NULL;
  48.         };
  49.     }
  50. }
  1. #include <glad/gl.h>
  2. #include <WindowManager/WindowManager.hpp>
  4. #include <utility>
  5. #include <iostream>
  7. namespace SoulByteEngineCore
  8. {
  9.     namespace WindowManager
  10.     {
  11.         Window::Window(unsigned int width, unsigned int height, const char *title)
  12.             :m_windowWidth{std :: move(width)}
  13.             ,m_windowHeight{std :: move(height)}
  14.             ,m_windowTitle{std :: move(title)}
  15.         {
  16.             CreateWindow();
  17.         }
  19.         void Window::Update()
  20.         {
  21.             glfwSwapBuffers(this->m_window_handle);
  22.             glfwPollEvents();
  23.         }
  25.         void Window::onUpdate()
  26.         {
  27.             Update();
  28.         }
  30.         void Window::Destroy()
  31.         {
  32.             glfwDestroyWindow(this->m_window_handle);
  33.         }
  35.         bool Window::ShouldClose()
  36.         {
  37.             return glfwWindowShouldClose(this->m_window_handle);
  38.         }
  40.         bool Window::Init()
  41.         {
  42.             if (!glfwInit())
  43.             {
  44.                 std::cout << "SoulByteEngine :: CORE :: WINDOW_MANAGER :: ERROR :: CRITICAL :: GLFW CANNOT BE INITIALIZED! " << std::endl;
  46.                 return false;
  47.             }
  48.         }
  50.         bool Window::CreateWindow()
  51.         {
  52.             glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  53.             glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  54.             glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  55.             m_window_handle = glfwCreateWindow(m_windowWidth, m_windowHeight, m_windowTitle, NULL, NULL);
  57.             if (!m_window_handle)
  58.             {
  59.                 std::cout << "SoulByteEngine :: CORE :: WindowManagerModule :: ERROR :: COULD'T CREATE WINDOW" << std::endl;
  61.                 return false;
  62.             }
  64.             glfwMakeContextCurrent(this->m_window_handle);
  66.             if (!gladLoadGL(glfwGetProcAddress))
  67.             {
  68.                 std::cout << "SoulByteEngine :: CORE :: WINDOW_MANAGER :: ERROR :: CRITICAL :: WINDOW HAS BEEN CREATED, BUT GLAD COULD NOT BE INITIALIZED! " << std::endl;
  69.                 return false;
  70.             }
  72.             return true;
  73.         }
  75.         bool Window::SetLogging()
  76.         {
  77.             return false;
  78.         }
  80.         unsigned int Window::GetWidth()
  81.         {
  82.             return this->m_windowWidth;
  83.         }
  85.         unsigned int Window::GetHeight()
  86.         {
  87.             return this->m_windowHeight;
  88.         }
  90.         const char* Window::GetTitle()
  91.         {
  92.             return this->m_windowTitle;
  93.         }
  95.         void Window::ShowWindowData()
  96.         {
  97.             std::cout << "Window Data:" << std::endl;
  98.             std::cout << "Title: " << this->GetTitle() << std::endl;
  99.             std::cout << "Width: " << this->GetWidth() << std::endl;
  100.             std::cout << "Height: " << this->GetHeight() << std::endl;
  101.         }
  103.         void Window::Clear(float x_pos, float y_pos, float z_pos)
  104.         {
  105.             glClearColor(x_pos, y_pos, z_pos, 1.0f);
  106.             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  107.         }
  109.     }
  110. }

Application.cpp

  1. #include <WindowManager/WindowManager.hpp>
  3. int main()
  4. {
  5.     if (SoulByteEngineCore::WindowManager::Window::Init())
  6.     {
  7.         SoulByteEngineCore::WindowManager::Window first_window(DEFAULT_WIDTH, DEFAULT_HEIGHT, "First Fuckin SoulByteEngine Window");
  8.         SoulByteEngineCore::WindowManager::Window second_window(DEFAULT_WIDTH, DEFAULT_HEIGHT, "Second Fuckin SoulByteEngine Window");
  10.         while (!first_window.ShouldClose() || !second_window.ShouldClose())
  11.         {
  12.             if (first_window.ShouldClose() == true)
  13.             {
  14.                 first_window.Destroy();
  15.             }
  16.             else
  17.             {
  18.                 //first_window.Clear(0.0f, 1.0f, 0.0f);
  19.                 first_window.onUpdate();
  20.             }
  21.             if (second_window.ShouldClose() == true)
  22.             {
  23.                 second_window.Destroy();
  24.             }
  25.             else
  26.             {
  27.                 //second_window.Clear(0.0f, 1.0f, 0.0f);
  28.                 second_window.onUpdate();
  29.             }
  31.         }
  32.     }
  33. }
c++

2条答案

按热度按时间
yzuktlbb

yzuktlbb1#

此答案基于用户@BDL的评论（架构问题）。
由于不能从回调调用glfwDestroyWindow（只能从主线程调用），所以必须采取不同的方法。
为此，我们需要两个列表（向量），一个是打开的（活动）窗口，另一个是关闭的（应该关闭标志集）窗口，例如：

  1. std::vector<GLFWwindow*> opened_windows;
  2. std::vector<GLFWwindow*> closing_windows;

两者最初都是空的，并且如果窗口被成功创建或被标记为被销毁，则被填充。
打开时（每当创建窗口时）：

  1. GLFWwindow *win = createWindow();
  2. if (win) {
  3.     opened_windows.push_back(win);
  4. }

对于关闭案例，我们必须建立一个关闭处理程序：

  1. void window_close_callback(GLFWwindow* win)
  2. {
  3.     //remove window from the opened list
  4.     opened_windows.erase(std::find(..., win));
  5.     //add to garbage list
  6.     closing_windows.push_back(win);
  7. }

然后在你的主循环中：

  1. while (!opened_windows.empty()) {
  2.     //1. do your stuff
  3.     //2. process events (which might catch a close event)
  4.     //3. destroy all windows in the garbage
  5.     if (!closing_windows.empty()) {
  6.         //foreach element in list, invoke glfwDestroyWindow
  7.         closing_windows.clear();
  8.     }
  9. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
um6iljoc

um6iljoc2#

感谢所有回答我问题的人！特别感谢@BDL！我知道我的架构真的很糟糕，因为我没有检查我的窗口是否关闭，我的Destroy（）方法正在关闭窗口，不管我的窗口是否已经关闭，因为你知道没有任何操作可以对已经关闭的窗口执行，并且对已经关闭的窗口采取的任何操作都会导致glfw崩溃。
所以，我已经修正了：
WindowManager.hpp:

  1. #include <GLFW/glfw3.h>
  3. #define DEFAULT_WIDTH 800
  4. #define DEFAULT_HEIGHT 600
  5. #define DEFAULT_TITLE "Soul Byte Engine Window"
  7. namespace SoulByteEngineCore
  8. {
  9.     namespace WindowManager
  10.     {
  11.         class Window
  12.         {
  13.         public:
  14.             Window(unsigned int width=DEFAULT_WIDTH, unsigned int height=DEFAULT_HEIGHT, const char *title = DEFAULT_TITLE);
  15.         public:
  16.             void Clear(float x_pos, float y_pos, float z_pos);
  17.         public:
  18.             unsigned int GetWidth();
  19.             unsigned int GetHeight();
  20.         public:
  21.             bool IsClosed();
  22.         public:
  23.             static bool Init();
  24.         public:
  25.             void ShowWindowData();
  26.         public:
  27.             const char* GetTitle();
  28.         public:
  29.             bool SetLogging();
  30.         public:
  31.             void onUpdate();
  32.         public:
  33.             bool ShouldClose();
  34.         public:
  35.             void Destroy();
  36.         private:
  37.             bool CreateWindow();
  38.         private:
  39.             void Update();
  40.         private:
  41.             unsigned int m_windowWidth = DEFAULT_WIDTH;
  42.             unsigned int m_windowHeight = DEFAULT_HEIGHT;
  43.         private:
  44.             const char* m_windowTitle = DEFAULT_TITLE;
  45.         private:
  46.             bool m_isClosed = false;
  47.         private:
  48.             unsigned int OpenGLMajorVersion = 3;
  49.             unsigned int OpenGLMinorVersion = 3;
  50.         private:
  51.             GLFWwindow* m_window_handle = NULL;
  52.         };
  53.     }
  54. }

WindowManager.cpp:

  1. #include <glad/gl.h>
  2. #include <WindowManager/WindowManager.hpp>
  4. #include <utility>
  5. #include <iostream>
  7. namespace SoulByteEngineCore
  8. {
  9.     namespace WindowManager
  10.     {
  11.         Window::Window(unsigned int width, unsigned int height, const char *title)
  12.             :m_windowWidth{std :: move(width)}
  13.             ,m_windowHeight{std :: move(height)}
  14.             ,m_windowTitle{std :: move(title)}
  15.         {
  16.             CreateWindow();
  17.         }
  19.         void Window::Update()
  20.         {
  21.             glfwSwapBuffers(this->m_window_handle);
  22.             glfwPollEvents();
  23.         }
  25.         void Window::onUpdate()
  26.         {
  27.             Update();
  28.         }
  30.         void Window::Destroy()
  31.         {
  32.             if (!m_isClosed)
  33.             {
  34.                 m_isClosed = true;
  35.                 glfwDestroyWindow(this->m_window_handle);
  36.             }
  37.         }
  39.         bool Window::ShouldClose()
  40.         {
  41.             return glfwWindowShouldClose(this->m_window_handle);
  42.         }
  44.         bool Window::Init()
  45.         {
  46.             if (!glfwInit())
  47.             {
  48.                 std::cout << "SoulByteEngine :: CORE :: WINDOW_MANAGER :: ERROR :: CRITICAL :: GLFW CANNOT BE INITIALIZED! " << std::endl;
  50.                 return false;
  51.             }
  52.         }
  54.         bool Window::CreateWindow()
  55.         {
  56.             glfwWindowHint(GLFW_CONTEXT_VERSION_MAJOR, 3);
  57.             glfwWindowHint(GLFW_CONTEXT_VERSION_MINOR, 3);
  58.             glfwWindowHint(GLFW_OPENGL_PROFILE, GLFW_OPENGL_CORE_PROFILE);
  59.             m_window_handle = glfwCreateWindow(m_windowWidth, m_windowHeight, m_windowTitle, NULL, NULL);
  61.             if (!m_window_handle)
  62.             {
  63.                 std::cout << "SoulByteEngine :: CORE :: WindowManagerModule :: ERROR :: COULD'T CREATE WINDOW" << std::endl;
  65.                 return false;
  66.             }
  68.             glfwMakeContextCurrent(this->m_window_handle);
  70.             if (!gladLoadGL(glfwGetProcAddress))
  71.             {
  72.                 std::cout << "SoulByteEngine :: CORE :: WINDOW_MANAGER :: ERROR :: CRITICAL :: WINDOW HAS BEEN CREATED, BUT GLAD COULD NOT BE INITIALIZED! " << std::endl;
  73.                 return false;
  74.             }
  76.             return true;
  77.         }
  79.         bool Window::SetLogging()
  80.         {
  81.             return false;
  82.         }
  84.         bool Window :: IsClosed()
  85.         {
  86.             return this->m_isClosed;
  87.         }
  89.         unsigned int Window::GetWidth()
  90.         {
  91.             return this->m_windowWidth;
  92.         }
  94.         unsigned int Window::GetHeight()
  95.         {
  96.             return this->m_windowHeight;
  97.         }
  99.         const char* Window::GetTitle()
  100.         {
  101.             return this->m_windowTitle;
  102.         }
  104.         void Window::ShowWindowData()
  105.         {
  106.             std::cout << "Window Data:" << std::endl;
  107.             std::cout << "Title: " << this->GetTitle() << std::endl;
  108.             std::cout << "Width: " << this->GetWidth() << std::endl;
  109.             std::cout << "Height: " << this->GetHeight() << std::endl;
  110.         }
  112.         void Window::Clear(float x_pos, float y_pos, float z_pos)
  113.         {
  114.             glClearColor(x_pos, y_pos, z_pos, 1.0f);
  115.             glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
  116.         }
  118.     }
  119. }

Application.cpp:

  1. #include <WindowManager/WindowManager.hpp>
  3. int main()
  4. {
  5.     if (SoulByteEngineCore::WindowManager::Window::Init())
  6.     {
  7.         SoulByteEngineCore::WindowManager::Window first_window(DEFAULT_WIDTH, DEFAULT_HEIGHT, "First Fuckin SoulByteEngine Window");
  8.         SoulByteEngineCore::WindowManager::Window second_window(DEFAULT_WIDTH, DEFAULT_HEIGHT, "Second Fuckin SoulByteEngine Window");
  10.         while (!first_window.IsClosed() || !second_window.IsClosed())
  11.         {
  12.             if (first_window.ShouldClose())
  13.             {
  14.                 first_window.Destroy();
  15.             }
  16.             else
  17.             {
  18.                 first_window.onUpdate();
  19.             }
  20.             if (second_window.ShouldClose())
  21.             {
  22.                 second_window.Destroy();
  23.             }
  24.             else
  25.             {
  26.                 second_window.onUpdate();
  27.             }
  28.         }
  29.     }
  30. }
展开查看全部
赞(0）分享  回复(0）举报  2023-06-25
我来回答

相关问题

    查看更多

    热门标签

    更多
    JavaquerypythonNode开发语言requestUtil数据库Table后端算法LoggerMessageElementParser

    最新问答

    更多
    • 蜀ICP备13028337号-1 大数据知识库 https://www.saoniuhuo.com © All rights reserved
    • 本站内容来源互联网,如果侵犯您的权益请联系我们删除, 联系方式：448109455@qq.com