c++ - 删除框架图时Qt3D崩溃

我正在尝试使用Qt3D创建一个应用程序，以便在同一场景中创建多个 View 窗口。我从Qt3DWindow和Simple C++ Example的代码开始，然后开始四处移动。我想到的是，每个 View 窗口将定义自己的框架图(现在仅使用简单的QForwardRenderer)和照相机，然后将每个窗口的框架图添加到场景中的主框架图。

创建多个窗口时，一切似乎工作正常，但是当我关闭窗口并开始删除框架图时，应用程序崩溃。它崩溃在Qt3DCore或Qt3DRender模块中某个地方的后台线程上，我无法获取源代码。据我了解，我应该能够在运行时动态修改框架图，但这不是线程安全的吗？您是否希望像我正在做的那样用一个框架图批量替换另一个框架图，而不是修改 Activity 框架图？

---编辑---

我做了一些测试，如果我从父框架图中删除了它的框架图之后，延迟了一段时间破坏QWindow(即它试图渲染的表面)，我不会崩溃。但是，我在控制台上确实收到一些警告:



我的猜测是这是一个线程问题，后端在主线程上被销毁后，仍在尝试使用QSurface进行渲染。我真的不喜欢我的解决方案(我只是使用一个计时器来将破坏窗口延迟1秒)，但是它比崩溃更好。

RenderWindow.h

#ifndef RENDERWINDOW_H
#define RENDERWINDOW_H
#include <QWindow>
#include <Qt3DCore>
#include <Qt3DRender>
#include <Qt3DInput>
#include <Qt3DExtras/QForwardRenderer>

class RenderWindow : public QWindow
{
public:
  RenderWindow(QScreen* screen = nullptr);
  ~RenderWindow();

  Qt3DRender::QCamera* camera() const;
  Qt3DRender::QFrameGraphNode* frameGraph() const;

protected:
  void resizeEvent(QResizeEvent *) override;

private:
  // Rendering
  Qt3DRender::QFrameGraphNode* mpFrameGraph;
  Qt3DRender::QCamera* mpCamera;

  static bool msFormatDefined;
};

#endif // RENDERWINDOW_H

RenderWindow.cpp

#include "renderwindow.h"
#include <QDebug>

bool RenderWindow::msFormatDefined = false;

namespace
{
    // Different clear colors so that it's obvious each window is using a
    // different camera and frame graph.
    static QColor sClearColors[] = {
        Qt::darkBlue,
        Qt::blue,
        Qt::darkCyan,
        Qt::cyan
    };
    static int sViewCount = 0;
}

RenderWindow::RenderWindow(QScreen* screen)
    : QWindow(screen)
    , mpFrameGraph(nullptr)
    , mpCamera(new Qt3DRender::QCamera)
{
    setSurfaceType(QWindow::OpenGLSurface);

    // Set the default surface format once
    if (!msFormatDefined)
    {
        QSurfaceFormat format;
        format.setVersion(4, 3);
        format.setProfile(QSurfaceFormat::CoreProfile);
        format.setDepthBufferSize(24);
        format.setSamples(4);
        format.setStencilBufferSize(8);
        setFormat(format);

        QSurfaceFormat::setDefaultFormat(format);
        msFormatDefined = true;
    }

    // Camera
    mpCamera->lens()->setPerspectiveProjection(45.0f, 16.0f/9.0f, 0.1f, 1000.0f);
    mpCamera->setPosition(QVector3D(0, 0, 40.0f));
    mpCamera->setViewCenter(QVector3D(0, 0, 0));

    // Frame Graph (using forward renderer for now)
    Qt3DExtras::QForwardRenderer* renderer = new Qt3DExtras::QForwardRenderer;
    renderer->setCamera(mpCamera);
    renderer->setSurface(this);
    renderer->setClearColor(sClearColors[sViewCount++ % 4]);
    mpFrameGraph = renderer;
}

RenderWindow::~RenderWindow()
{
    qDebug() << "start ~RenderWindow";

    // Unparent objects.  Probably not necessary but it makes me feel
    // good inside.
    mpFrameGraph->setParent(static_cast<Qt3DCore::QNode*>(nullptr));
    mpCamera->setParent(static_cast<Qt3DCore::QNode*>(nullptr));

    delete mpFrameGraph;
    delete mpCamera;

    qDebug() << "end ~RenderWindow";
}

Qt3DRender::QCamera* RenderWindow::camera() const
{
    return mpCamera;
}

Qt3DRender::QFrameGraphNode* RenderWindow::frameGraph() const
{
    return mpFrameGraph;
}

void RenderWindow::resizeEvent(QResizeEvent *)
{
    mpCamera->setAspectRatio((float)width()/(float)height());
}

Scene.h

#ifndef SCENE_H
#define SCENE_H
#include <Qt3DCore/QEntity>

#include <Qt3DInput/QInputAspect>

#include <Qt3DRender/QFrameGraphNode>
#include <Qt3DRender/QRenderAspect>
#include <Qt3DRender/QRenderSettings>

class RenderWindow;

class Scene
{
public:
    Scene();
    ~Scene();

    Qt3DCore::QEntityPtr rootNode() const;

    void addView(RenderWindow* window);

private:
    void setupScene();

private:
    Qt3DCore::QEntityPtr mpRoot;

    // Frame Graph
    Qt3DRender::QFrameGraphNode* mpFrameGraph;
    Qt3DRender::QRenderSettings* mpRenderSettings;

    // Aspects
    Qt3DCore::QAspectEngine* mpEngine;
    Qt3DRender::QRenderAspect* mpRenderAspect;
    Qt3DInput::QInputAspect* mpInputAspect;
};

#endif // SCENE_H

Scene.cpp

#include "scene.h"

#include <QDebug>
#include <QPropertyAnimation>

#include <Qt3DCore/QTransform>

#include <Qt3DRender/QClearBuffers>

#include <Qt3DExtras/QPhongMaterial>
#include <Qt3DExtras/QCylinderMesh>
#include <Qt3DExtras/QSphereMesh>
#include <Qt3DExtras/QTorusMesh>

#include "orbittransformcontroller.h"
#include "RenderWindow.h"

Scene::Scene()
    : mpRoot(nullptr)
    , mpFrameGraph(new Qt3DRender::QFrameGraphNode)
    , mpRenderSettings(new Qt3DRender::QRenderSettings)
    , mpEngine(new Qt3DCore::QAspectEngine)
    , mpRenderAspect(new Qt3DRender::QRenderAspect)
    , mpInputAspect(new Qt3DInput::QInputAspect)
{
    mpEngine->registerAspect(mpRenderAspect);

    mpRenderSettings->setActiveFrameGraph(mpFrameGraph);

    setupScene();

    mpRoot->addComponent(mpRenderSettings);
    mpEngine->setRootEntity(mpRoot);
}

Scene::~Scene()
{
    qDebug() << "start ~Scene";

    mpEngine->setRootEntity(Qt3DCore::QEntityPtr());
    mpRoot.clear();

    delete mpEngine;
    // mpRenderSettings and mpFrameGraph are children of the
    // root node and are automatically destroyed when it is.

    qDebug() << "end ~Scene";
}

Qt3DCore::QEntityPtr Scene::rootNode() const
{
    return mpRoot;
}

void Scene::addView(RenderWindow* window)
{
    // Add the window's frame graph to the main frame graph
    if (window->frameGraph())
    {
        window->frameGraph()->setParent(mpFrameGraph);
    }
}

void Scene::setupScene()
{
    mpRoot.reset(new Qt3DCore::QEntity);

    Qt3DCore::QEntity* entity = new Qt3DCore::QEntity;
    entity->setParent(mpRoot.data());

    // Create the material
    Qt3DExtras::QPhongMaterial *material = new Qt3DExtras::QPhongMaterial(entity);
    material->setAmbient(Qt::black);
    material->setDiffuse(QColor(196, 196, 32));
    material->setSpecular(Qt::white);

    // Torrus
    Qt3DCore::QEntity *torusEntity = new Qt3DCore::QEntity(entity);
    Qt3DExtras::QTorusMesh *torusMesh = new Qt3DExtras::QTorusMesh;
    torusMesh->setRadius(5);
    torusMesh->setMinorRadius(1);
    torusMesh->setRings(100);
    torusMesh->setSlices(20);

    Qt3DCore::QTransform *torusTransform = new Qt3DCore::QTransform;
    torusTransform->setScale3D(QVector3D(1.5, 1, 0.5));
    torusTransform->setRotation(QQuaternion::fromAxisAndAngle(QVector3D(1, 0, 0), -45.0f));

    torusEntity->addComponent(torusMesh);
    torusEntity->addComponent(torusTransform);
    torusEntity->addComponent(material);

    // Sphere
    Qt3DCore::QEntity *sphereEntity = new Qt3DCore::QEntity(entity);
    Qt3DExtras::QSphereMesh *sphereMesh = new Qt3DExtras::QSphereMesh;
    sphereMesh->setRadius(3);

    Qt3DCore::QTransform *sphereTransform = new Qt3DCore::QTransform;
    /*OrbitTransformController *controller = new OrbitTransformController(sphereTransform);
    controller->setTarget(sphereTransform);
    controller->setRadius(20.0f);

    QPropertyAnimation *sphereRotateTransformAnimation = new QPropertyAnimation(sphereTransform);
    sphereRotateTransformAnimation->setTargetObject(controller);
    sphereRotateTransformAnimation->setPropertyName("angle");
    sphereRotateTransformAnimation->setStartValue(QVariant::fromValue(0));
    sphereRotateTransformAnimation->setEndValue(QVariant::fromValue(360));
    sphereRotateTransformAnimation->setDuration(10000);
    sphereRotateTransformAnimation->setLoopCount(-1);
    sphereRotateTransformAnimation->start();*/

    sphereEntity->addComponent(sphereMesh);
    sphereEntity->addComponent(sphereTransform);
    sphereEntity->addComponent(material);
}

MainWindow.h

#ifndef MAINWINDOW_H
#define MAINWINDOW_H

#include <QMainWindow>

#include "scene.h"

namespace Ui {
class MainWindow;
}

class MainWindow : public QMainWindow
{
    Q_OBJECT

public:
    explicit MainWindow(QWidget *parent = 0);
    ~MainWindow();

    void createWindow();

private:
    Ui::MainWindow *ui;
    Scene* scene;
};

#endif // MAINWINDOW_H

MainWindow.cpp

#include "mainwindow.h"
#include <QDebug>
#include "ui_mainwindow.h"
#include "renderwindow.h"

MainWindow::MainWindow(QWidget *parent) :
    QMainWindow(parent),
    ui(new Ui::MainWindow),
    scene(new Scene())
{
    ui->setupUi(this);
    connect(ui->createButton, &QPushButton::clicked, this, &MainWindow::createWindow);
}

MainWindow::~MainWindow()
{
    qDebug() << "~MainWindow";

    delete scene;
    delete ui;
}

void MainWindow::createWindow()
{
    RenderWindow* window = new RenderWindow();
    scene->addView(window);
    window->resize(640, 480);
    window->show();

    QVector3D pos[] = {
        QVector3D(0, 0, 40),
        QVector3D(0, 25, -30),
        QVector3D(-20, -20, -20),
        QVector3D(40, 0, 0)
    };
    static int count = 0;
    window->camera()->setPosition(pos[count++%4]);
    window->camera()->setViewCenter(QVector3D(0, 0, 0));

    // Delete the window when it is closed.
    connect(window, &QWindow::visibilityChanged, this, [=](bool on)
    {
        if (!on)
            window->deleteLater();
    });
}

最佳答案

我已经彻底测试了您的示例，并得出了相同的结论。当您太快地破坏窗口时，应用程序将崩溃，可能是因为Qt3D仍然尝试向基础QSurface发出一些OpenGL命令。我认为这是应该报告的错误。

此问题的“更清洁”的解决方法可能是在主窗口中跟踪生成的3d窗口。您可以维护一个指向所有已生成窗口的指针的列表(有时用户可能已将其关闭)。窗口最终在主窗口的析构函数中销毁。