Regarding the swapchain validation layer issue caused by multiple QWidgets in vsgQt.

[zhuzhiyong8679]

question

When I use the vsgqtwindows and vsgqtmdi examples, everything works correctly. However, when I made some modifications to vsgqtwindows — using QStackedWidget to create three QWidgets stacked on top of vsgQt::Window and switching between them — a problem occurs.
The validation layer error is as follows：

error

VUID-vkAcquireNextImageKHR-surface-07783(ERROR / SPEC): msgNum: -1391585802 - Validation Error: [ VUID-vkAcquireNextImageKHR-surface-07783 ] Object 0: handle = 0x1bc00000001bc, type = VK_OBJECT_TYPE_SWAPCHAIN_KHR; | MessageID = 0xad0e15f6 | vkAcquireNextImageKHR(): Application has already previously acquired 2 images from swapchain. Only 2 are available to be acquired using a timeout of UINT64_MAX (given the swapchain has 3, and VkSurfaceCapabilitiesKHR::minImageCount is 2). The Vulkan spec states: If forward progress cannot be guaranteed for the surface used to create the swapchain member of pAcquireInfo, the timeout member of pAcquireInfo must not be UINT64_MAX (https://www.khronos.org/registry/vulkan/specs/1.3-extensions/html/vkspec.html#VUID-vkAcquireNextImageKHR-surface-07783) Objects: 1 [0] 0x1bc00000001bc, type: 1000001000, name: NULL

codes:

#include <vsg/all.h>
 #ifdef vsgXchange_FOUND
 #include <vsgXchange/all.h>
 #endif
 #include <QtWidgets/QApplication>
 #include <QtWidgets/QMainWindow>
 #include <QtWidgets/QMdiArea>
 #include <QtWidgets/QStackedWidget>
 #include <vsgQt/Window.h>
 #include <QtWidgets/QShortcut>
 #include <iostream>
 vsgQt::Window* createWindow(vsg::ref_ptr<vsgQt::Viewer> viewer, vsg::ref_ptr<vsg::WindowTraits> traits,  vsg::ref_ptr<vsg::Node> vsg_scene, QWindow* parent, const QString& title = {})
 {
     auto window = new vsgQt::Window(viewer, traits, parent);
     window->setTitle(title);
     window->initializeWindow();
     // if this is the first window to be created, use its device for future window creation.
     if (!traits->device) traits->device = window->windowAdapter->getOrCreateDevice();
     // compute the bounds of the scene graph to help position camera
     vsg::ComputeBounds computeBounds;
     vsg_scene->accept(computeBounds);
     vsg::dvec3 centre = (computeBounds.bounds.min + computeBounds.bounds.max) * 0.5;
     double radius = vsg::length(computeBounds.bounds.max - computeBounds.bounds.min) * 0.6;
     double nearFarRatio = 0.001;
     uint32_t width = window->traits->width;
     uint32_t height = window->traits->height;
     vsg::ref_ptr<vsg::EllipsoidModel> ellipsoidModel(vsg_scene->getObject<vsg::EllipsoidModel>("EllipsoidModel"));
     vsg::ref_ptr<vsg::Camera> camera;
     {
         // set up the camera
         auto lookAt = vsg::LookAt::create(centre + vsg::dvec3(0.0, -radius * 3.5, 0.0), centre, vsg::dvec3(0.0, 0.0, 1.0));
         vsg::ref_ptr<vsg::ProjectionMatrix> perspective;
         if (ellipsoidModel)
         {
             perspective = vsg::EllipsoidPerspective::create(
                 lookAt, ellipsoidModel, 30.0,
                 static_cast<double>(width) /
                     static_cast<double>(height),
                 nearFarRatio, false);
         }
         else
         {
             perspective = vsg::Perspective::create(
                 30.0,
                 static_cast<double>(width) /
                     static_cast<double>(height),
                 nearFarRatio * radius, radius * 4.5);
         }
         camera = vsg::Camera::create(perspective, lookAt, vsg::ViewportState::create(VkExtent2D{width, height}));
     }
     auto trackball = vsg::Trackball::create(camera, ellipsoidModel);
     trackball->addWindow(*window);
     viewer->addEventHandler(trackball);
     auto commandGraph = vsg::createCommandGraphForView(*window, camera, vsg_scene);
     viewer->addRecordAndSubmitTaskAndPresentation({commandGraph});
     return window;
 }
 class mainwindow:public QMainWindow
 {
 public:
     mainwindow()
     {
        stackWidget=new QStackedWidget(this);
         setCentralWidget(stackWidget);
         new QShortcut(QKeySequence(Qt::Key_1), this, [this]() {
     stackWidget->setCurrentIndex(0);
 });
         new QShortcut(QKeySequence(Qt::Key_2), this, [this]() {
             stackWidget->setCurrentIndex(1);
         });
         new QShortcut(QKeySequence(Qt::Key_3), this, [this]() {
             stackWidget->setCurrentIndex(2);
         });
     };
     void addWidget(QWidget* widget)
     {
              stackWidget->addWidget(widget);
     }
 
    private:
        QStackedWidget *stackWidget;
 };

  int main(int argc, char* argv[])
  {

     QApplication application(argc, argv);
     vsg::CommandLine arguments(&argc, argv);
     // set up vsg::Options to pass in filepaths, ReaderWriters and other IO
     // related options to use when reading and writing files.
     auto options = vsg::Options::create();
     options->fileCache = vsg::getEnv("VSG_FILE_CACHE");
     options->paths = vsg::getEnvPaths("VSG_FILE_PATH");
     #ifdef vsgXchange_FOUND
     options->add(vsgXchange::all::create());
     #endif
     options->readOptions(arguments);
     auto windowTraits = vsg::WindowTraits::create();
     windowTraits->windowTitle = "vsgQt viewer";
     windowTraits->debugLayer = true;
     windowTraits->apiDumpLayer = arguments.read({"--api", "-a"});
     arguments.read("--samples", windowTraits->samples);
     arguments.read({"--window", "-w"}, windowTraits->width, windowTraits->height);
     if (arguments.read({"--fullscreen", "--fs"})) windowTraits->fullscreen = true;
     bool continuousUpdate = !arguments.read({"--event-driven", "--ed"});
     auto interval = arguments.value<int>(8, "--interval");
 
     if (arguments.errors())
         return arguments.writeErrorMessages(std::cerr);
 
     if (argc <= 1)
     {
         std::cout << "Please specify a 3d model or image file on the command line."
                   << std::endl;
         return 1;
     }
 
     vsg::Path filename = arguments[1];
 
     auto vsg_scene = vsg::read_cast<vsg::Node>("models/teapot.vsgt", options);
     if (!vsg_scene)
     {
         std::cout << "Failed to load a valid scene graph. Please specify a valid 3d "
                      "model or image file on the command line."
                   << std::endl;
     }
     auto vsg_scene1=vsg::read_cast<vsg::Node>("/models/lz.vsgt", options);
     // create the viewer that will manage all the rendering of the views
     auto viewer = vsgQt::Viewer::create();
     // add close handler to respond to the close window button and pressing escape
     viewer->addEventHandler(vsg::CloseHandler::create(viewer));
     mainwindow mainWindow;
 
     auto firstWindow = createWindow(viewer, windowTraits, vsg_scene, nullptr, "First Window");
     auto secondWindow = createWindow(viewer, windowTraits, vsg_scene1, nullptr, "Second Window");
     auto thirdWindow = createWindow(viewer, windowTraits, vsg_scene, nullptr, "Second Window");
 
     auto firstwidget = QWidget::createWindowContainer(firstWindow, &mainWindow);
     auto secondwidget = QWidget::createWindowContainer(secondWindow, &mainWindow);
     auto thirdwidget = QWidget::createWindowContainer(thirdWindow, &mainWindow);
     mainWindow.addWidget(firstwidget);
     mainWindow.addWidget(secondwidget);
     mainWindow.addWidget(thirdwidget);
     mainWindow.setGeometry(windowTraits->x, windowTraits->y, windowTraits->width, windowTraits->height);
     mainWindow.show();
     if (interval >= 0) viewer->setInterval(interval);
     viewer->continuousUpdate = continuousUpdate;
     viewer->compile();
     return application.exec(); }

I modified the code of vsgqtwindows. When I switch to the third page, a validation layer error occurs. What should I do? Thank you again. Finally, I think different Qt components might produce different effects. For example, QStackedWidget hides non‑current pages. I suppose I should do something in the Window::hideEvent(QHideEvent* /e/) function.