qquick3dscenemanager.cpp

Go to the documentation of this file.

// Copyright (C) 2019 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only
// Qt-Security score:significant reason:default
 
 
#include "qquick3dscenemanager_p.h"
#include "qquick3dobject_p.h"
#include "qquick3dviewport_p.h"
#include "qquick3dmodel_p.h"
 
#include <QtQuick/QQuickWindow>
 
#include <QtQuick3DRuntimeRender/private/qssgrenderlayer_p.h>
#include <ssg/qssgrendercontextcore.h>
#include <QtQuick3DRuntimeRender/private/qssgrendermodel_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderer_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderimage_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderlayer_p.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderroot_p.h>
#include <QtQuick3DRuntimeRender/ssg/qssgrenderextensions.h>
#include <QtQuick3DRuntimeRender/private/qssgrenderuserpass_p.h>
 
#include <QtQuick3DUtils/private/qssgassert_p.h>
 
#include "qquick3drenderextensions.h"
 
QT_BEGIN_NAMESPACE
 
// NOTE: Another indiraction to try to clean-up resource in a nice way.
QSSGCleanupObject::QSSGCleanupObject(std::shared_ptr<QSSGRenderContextInterface> rci, QList<QSSGRenderGraphObject *> resourceCleanupQueue, QQuickWindow *window)
    : QObject(window)
    , m_rci(rci)
    , m_window(window)
    , m_resourceCleanupQueue(resourceCleanupQueue)
{
    Q_ASSERT(window != nullptr && rci); // We need a window and a rci for this!
 
    if (QSGRenderContext *rc = QQuickWindowPrivate::get(window)->context) {
        connect(rc, &QSGRenderContext::releaseCachedResourcesRequested, this, &QSSGCleanupObject::cleanupResources, Qt::DirectConnection);
        connect(rc, &QSGRenderContext::invalidated, this, &QSSGCleanupObject::cleanupResources, Qt::DirectConnection);
    } else {
        qWarning() << "No QSGRenderContext, cannot cleanup resources!";
    }
}
 
QSSGCleanupObject::~QSSGCleanupObject()
{
    QSSG_CHECK(QSSG_DEBUG_COND(m_resourceCleanupQueue.isEmpty()));
}
 
void QSSGCleanupObject::cleanupResources()
{
    m_rci->renderer()->cleanupResources(m_resourceCleanupQueue);
    deleteLater();
}
 
static constexpr char qtQQ3DWAPropName[] { "_qtquick3dWindowAttachment" };
 
static void detachDirtyList(QQuick3DObject **head, size_t count)
{
    for (size_t i = 0; i < count; ++i) {
        QQuick3DObject *item = head[i];
        while (item) {
            QQuick3DObjectPrivate *p = QQuick3DObjectPrivate::get(item);
            QQuick3DObject *next = p->nextDirtyItem;
            p->prevDirtyItem = nullptr;
            p->nextDirtyItem = nullptr;
            item = next;
        }
        head[i] = nullptr;
    }
}
 
QQuick3DSceneManager::QQuick3DSceneManager(QObject *parent)
    : QObject(parent)
{
}
 
// Should be deleted by QQuick3DWindowAttachment to ensure it's done
// on the render thread.
QQuick3DSceneManager::~QQuick3DSceneManager()
{
    cleanupNodes();
    if (wattached)
        wattached->unregisterSceneManager(*this);
 
    // Objects still on one of our dirty lists hold a 'prevDirtyItem' pointer into the arrays
    // below, which are freed together with this manager. Detach them now so a later
    // removeFromDirtyList(), e.g. when the front-end object is itself destroyed, is a safe
    // no-op instead of writing through a stale pointer. The normal per-frame drain only
    // happens for active managers in synchronize(), not for one that was queued for cleanup.
    //
    // NOTE!!!: If these dirty objects are shared they will be re-queued by the surviving manager,
    // but if they are not shared they will be dropped on the floor, which is fine, because they're not
    // active and will either be destroyed or added to a new scene.
    // The re-adoption happens because the destroyed() signal of this manager is connected to
    // QQuick3DViewport::updateSceneManagerForImportScene(), which calls refSceneManager() on any
    // surviving view, which in turn calls dirty() on any shared objects, which adds them to the
    // dirty list if they're not already in one.
    detachDirtyList(dirtyResources, std::size(dirtyResources));
    detachDirtyList(dirtyNodes, std::size(dirtyNodes));
    detachDirtyList(dirtyExtensions, std::size(dirtyExtensions));
}
 
void QQuick3DSceneManager::setWindow(QQuickWindow *window)
{
    if (window == m_window)
        return;
 
    if (window != m_window) {
        if (wattached) {
            // Unregister from old windows attached object
            wattached->unregisterSceneManager(*this);
            wattached = nullptr;
        }
        m_window = window;
        if (m_window) {
            wattached = getOrSetWindowAttachment(*m_window);
            if (wattached)
                wattached->registerSceneManager(*this);
        }
 
        emit windowChanged();
    }
}
 
QQuickWindow *QQuick3DSceneManager::window()
{
    return m_window;
}
 
void QQuick3DSceneManager::dirtyItem(QQuick3DObject *item)
{
    Q_UNUSED(item);
    emit needsUpdate();
}
 
void QQuick3DSceneManager::requestUpdate()
{
    emit needsUpdate();
}
 
void QQuick3DSceneManager::cleanup(QSSGRenderGraphObject *item)
{
    cleanupNodeList.insert(item);
 
    if (auto front = m_nodeMap[item]) {
        auto *po = QQuick3DObjectPrivate::get(front);
        sharedResourceRemoved |= po->sharedResource;
        po->spatialNode = nullptr;
 
        // The front-end object is no longer reachable (destroyed) so make sure we don't return it
        // when doing a node look-up.
        m_nodeMap[item] = nullptr;
    }
}
 
void QQuick3DSceneManager::polishItems()
{
 
}
 
void QQuick3DSceneManager::forcePolish()
{
 
}
 
void QQuick3DSceneManager::sync()
{
 
}
 
void QQuick3DSceneManager::updateBoundingBoxes(QSSGBufferManager &mgr)
{
    if (lightmapSourceTracker.isDirty) {
        mgr.setLightmapSource(lightmapSourceTracker.lightmapSource);
        lightmapSourceTracker.isDirty = false;
    }
 
    for (auto *object : std::as_const(dirtyBoundingBoxList)) {
        QQuick3DObjectPrivate *itemPriv = QQuick3DObjectPrivate::get(object);
        if (itemPriv->sceneManager == nullptr)
            continue;
        auto model = static_cast<QSSGRenderModel *>(itemPriv->spatialNode);
        if (model) {
            QSSGBounds3 bounds = mgr.getModelBounds(model);
            static_cast<QQuick3DModel *>(object)->setBounds(bounds.minimum, bounds.maximum);
        }
    }
 
    dirtyBoundingBoxList.clear();
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::updateDirtyResourceNodes()
{
    SyncResult ret = SyncResultFlag::None;
 
    auto it = std::begin(dirtyResources);
    const auto end = std::end(dirtyResources);
    for (; it != end; ++it)
        ret |= updateResources(it);
 
    return ret;
}
 
void QQuick3DSceneManager::updateDirtySpatialNodes()
{
    auto it = std::begin(dirtyNodes);
    const auto end = std::end(dirtyNodes);
    for (; it != end; ++it)
        updateNodes(it);
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::updateDiryExtensions()
{
    SyncResult ret = SyncResultFlag::None;
 
    auto it = std::begin(dirtyExtensions);
    const auto end = std::end(dirtyExtensions);
    for (; it != end; ++it)
        ret |= updateExtensions(it);
 
    return ret;
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::updateDirtyResourceSecondPass()
{
    const auto updateDirtyResourceNode = [this](QQuick3DObject *resource) {
        QQuick3DObjectPrivate *po = QQuick3DObjectPrivate::get(resource);
        po->dirtyAttributes = 0; // Not used, but we should still reset it.
        po->secondaryUpdateRequested = false;
        QSSGRenderGraphObject *node = po->spatialNode;
        po->spatialNode = resource->updateSpatialNode(node);
        if (po->spatialNode)
            m_nodeMap.insert(po->spatialNode, resource);
        return po->sharedResource ? SyncResultFlag::SharedResourcesDirty : SyncResultFlag::None;
    };
 
    SyncResult res = SyncResultFlag::None;
    auto it = dirtySecondPassResources.constBegin();
    const auto end = dirtySecondPassResources.constEnd();
    for (; it != end; ++it)
        res |= updateDirtyResourceNode(*it);
 
    // Expectation is that we won't get here often, for other updates the
    // backend nodes should have been realized and we won't get here, so
    // just release space used by the set.
    dirtySecondPassResources = {};
 
    return res;
}
 
void QQuick3DSceneManager::updateDirtyResource(QQuick3DObject *resourceObject)
{
    QQuick3DObjectPrivate *itemPriv = QQuick3DObjectPrivate::get(resourceObject);
    quint32 dirty = itemPriv->dirtyAttributes;
    Q_UNUSED(dirty);
    itemPriv->dirtyAttributes = 0;
    QSSGRenderGraphObject *oldNode = itemPriv->spatialNode;
    QSSGRenderGraphObject *newNode = resourceObject->updateSpatialNode(itemPriv->spatialNode);
 
    const bool backendNodeChanged = oldNode != newNode;
 
    // If the backend resource object changed, we need to clean up the old one.
    if (oldNode && backendNodeChanged)
        cleanup(oldNode);
 
    // NOTE: cleanup() will remove the item from the node map and set the spatial node to nullptr.
    //       so we need to set it here.
    itemPriv->spatialNode = newNode;
 
    if (itemPriv->spatialNode) {
        m_nodeMap.insert(itemPriv->spatialNode, resourceObject);
        if (itemPriv->spatialNode->type == QSSGRenderGraphObject::Type::ResourceLoader) {
            resourceLoaders.insert(itemPriv->spatialNode);
        } else if (itemPriv->spatialNode->type == QQuick3DObjectPrivate::Type::Image2D && backendNodeChanged) {
            ++inputHandlingEnabled;
        } else if (QSSGRenderGraphObjectUtils::isUserRenderPass(itemPriv->type) && itemPriv->spatialNode) {
            auto *userRenderPass = static_cast<QSSGRenderUserPass *>(itemPriv->spatialNode);
            if (const auto idx = userRenderPasses.indexOf(userRenderPass); idx == -1) {
                userRenderPasses.push_back(userRenderPass);
                userRenderPassesDirty = true;
            }
        }
    }
 
    if (itemPriv->hasFlag(QQuick3DObjectPrivate::Flags::RequiresSecondaryUpdate) && itemPriv->secondaryUpdateRequested)
        dirtySecondPassResources.insert(resourceObject);
 
    // resource nodes dont go in the tree, so we dont need to parent them
}
 
void QQuick3DSceneManager::updateDirtySpatialNode(QQuick3DNode *spatialNode)
{
    const auto prepNewSpatialNode = [this](QSSGRenderNode *node) {
        if (node) {
            node->rootNodeRef = wattached->rootNode()->rootNodeRef;
            Q_ASSERT(QSSGRenderRoot::get(node->rootNodeRef) != nullptr);
        }
    };
 
    QQuick3DObjectPrivate *itemPriv = QQuick3DObjectPrivate::get(spatialNode);
    quint32 dirty = itemPriv->dirtyAttributes;
    itemPriv->dirtyAttributes = 0;
    QSSGRenderGraphObject *oldNode = itemPriv->spatialNode;
    QSSGRenderGraphObject *newNode = spatialNode->updateSpatialNode(oldNode);
 
    const bool backendNodeChanged = oldNode != newNode;
 
    // If the backend node changed, we need to clean up the old one.
    if (oldNode && backendNodeChanged)
        cleanup(oldNode);
 
    // NOTE: cleanup() will remove the item from the node map and set the spatial node to nullptr.
    //       so we need to set it here.
    itemPriv->spatialNode = newNode;
    prepNewSpatialNode(static_cast<QSSGRenderNode *>(itemPriv->spatialNode));
 
    // NOTE: We always update the node map, as we can end-up with the a node map where the mapping
    // has been 'disconnected', e.g., the front-end object removed from the scene only to be later
    // re-used.
    if (itemPriv->spatialNode) {
        m_nodeMap.insert(itemPriv->spatialNode, spatialNode);
        if (itemPriv->type == QQuick3DObjectPrivate::Type::Item2D && itemPriv->spatialNode != oldNode)
            ++inputHandlingEnabled;
    }
 
    QSSGRenderNode *graphNode = static_cast<QSSGRenderNode *>(itemPriv->spatialNode);
 
    if (graphNode && graphNode->parent && dirty & QQuick3DObjectPrivate::ParentChanged) {
        QQuick3DNode *nodeParent = qobject_cast<QQuick3DNode *>(spatialNode->parentItem());
        if (nodeParent) {
            QSSGRenderNode *parentGraphNode = static_cast<QSSGRenderNode *>(
                        QQuick3DObjectPrivate::get(nodeParent)->spatialNode);
            if (parentGraphNode) {
                graphNode->parent->removeChild(*graphNode);
                parentGraphNode->addChild(*graphNode);
            }
        }
    }
 
    if (graphNode && graphNode->parent == nullptr) {
        QQuick3DNode *nodeParent = qobject_cast<QQuick3DNode *>(spatialNode->parentItem());
        if (nodeParent) {
            QSSGRenderNode *parentGraphNode = static_cast<QSSGRenderNode *>(QQuick3DObjectPrivate::get(nodeParent)->spatialNode);
            if (!parentGraphNode) {
                // The parent spatial node hasn't been created yet
                auto parentNode = QQuick3DObjectPrivate::get(nodeParent);
                parentNode->spatialNode = nodeParent->updateSpatialNode(parentNode->spatialNode);
                if (parentNode->spatialNode)
                    m_nodeMap.insert(parentNode->spatialNode, nodeParent);
                parentGraphNode = static_cast<QSSGRenderNode *>(parentNode->spatialNode);
                prepNewSpatialNode(parentGraphNode);
            }
            if (parentGraphNode)
                parentGraphNode->addChild(*graphNode);
        } else {
            QQuick3DViewport *viewParent = qobject_cast<QQuick3DViewport *>(spatialNode->parent());
            if (viewParent) {
                auto sceneRoot = QQuick3DObjectPrivate::get(viewParent->scene());
                if (!sceneRoot->spatialNode) // must have a scene root spatial node first
                    sceneRoot->spatialNode = viewParent->scene()->updateSpatialNode(sceneRoot->spatialNode);
                if (sceneRoot->spatialNode) {
                    auto *sceneRootNode = static_cast<QSSGRenderNode *>(sceneRoot->spatialNode);
                    prepNewSpatialNode(sceneRootNode);
                    m_nodeMap.insert(sceneRootNode, viewParent->scene());
                    sceneRootNode->addChild(*graphNode);
                }
            }
        }
    }
}
 
QQuick3DObject *QQuick3DSceneManager::lookUpNode(const QSSGRenderGraphObject *node) const
{
    return m_nodeMap[const_cast<QSSGRenderGraphObject *>(node)];
}
 
QQuick3DWindowAttachment *QQuick3DSceneManager::getOrSetWindowAttachment(QQuickWindow &window)
{
 
    QQuick3DWindowAttachment *wa = nullptr;
    if (auto aProperty = window.property(qtQQ3DWAPropName); aProperty.isValid())
        wa = aProperty.value<QQuick3DWindowAttachment *>();
 
    if (!wa) {
        // WindowAttachment will not be created under 'window'.
        // It should be deleted after all the cleanups related with 'window',
        // otherwise some resourses deleted after it, will not be cleaned correctly.
        wa = new QQuick3DWindowAttachment(&window);
        window.setProperty(qtQQ3DWAPropName, QVariant::fromValue(wa));
    }
 
    return wa;
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::cleanupNodes()
{
    SyncResult res = sharedResourceRemoved ? SyncResultFlag::SharedResourcesDirty : SyncResultFlag::None;
    // Reset the shared resource removed value.
    sharedResourceRemoved = false;
    for (auto node : std::as_const(cleanupNodeList)) {
        // Remove "spatial" nodes from scenegraph
        if (QSSGRenderGraphObject::isNodeType(node->type)) {
            QSSGRenderNode *spatialNode = static_cast<QSSGRenderNode *>(node);
            spatialNode->removeFromGraph();
        }
 
        if (node->type == QQuick3DObjectPrivate::Type::Item2D) {
            --inputHandlingEnabled;
        } else if (node->type == QQuick3DObjectPrivate::Type::Image2D) {
            auto image = static_cast<QSSGRenderImage *>(node);
            if (image && image->m_qsgTexture != nullptr ) {
                --inputHandlingEnabled;
            }
        }
 
        // Remove all nodes from the node map because they will no
        // longer be usable from this point from the frontend
        m_nodeMap.remove(node);
 
        if (QSSGRenderGraphObjectUtils::hasInternalFlag(*node, QSSGRenderGraphObjectUtils::InternalFlags::AutoRegisterExtension)) {
            autoRegisteredExtensions.removeAll(node);
            autoRegisteredExtensionsDirty = true;
        }
 
        if (QSSGRenderGraphObjectUtils::isUserRenderPass(node->type)) {
            auto *userRenderPass = static_cast<QSSGRenderUserPass *>(node);
            if (qsizetype idx = userRenderPasses.indexOf(userRenderPass); idx != -1) {
                userRenderPasses.remove(idx);
                userRenderPassesDirty = true;
            }
        }
 
        // Some nodes will trigger resource cleanups that need to
        // happen at a specified time (when graphics backend is active)
        // So build another queue for graphics assets marked for removal
        if (node->hasGraphicsResources()) {
            wattached->queueForCleanup(node);
            if (node->type == QSSGRenderGraphObject::Type::ResourceLoader)
                resourceLoaders.remove(node);
        } else {
            delete node;
        }
    }
 
    // Nodes are now "cleaned up" so clear the cleanup list
    cleanupNodeList.clear();
 
    return res;
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::updateResources(QQuick3DObject **listHead)
{
    SyncResult res = SyncResultFlag::None;
 
    // Detach the current list head first, and consume all reachable entries.
    // New entries may be added to the new list while traversing, which will be
    // visited on the next updateDirtyNodes() call.
    bool hasSharedResources = false;
    QQuick3DObject *updateList = *listHead;
    *listHead = nullptr;
    if (updateList)
        QQuick3DObjectPrivate::get(updateList)->prevDirtyItem = &updateList;
 
    QQuick3DObject *item = updateList;
    while (item) {
        // Different processing for resource nodes vs hierarchical nodes etc.
        Q_ASSERT(!QSSGRenderGraphObject::isNodeType(QQuick3DObjectPrivate::get(item)->type) || !QSSGRenderGraphObject::isExtension(QQuick3DObjectPrivate::get(item)->type));
        // handle hierarchical nodes
        auto *po = QQuick3DObjectPrivate::get(item);
        // Unlink before calling updateSpatialNode() below: if that call re-enters dirty() on
        // this very object (e.g. via a QML binding evaluated as a side effect of the update),
        // dirty() needs prevDirtyItem to already be null so it re-links the object via its own
        // addToDirtyList() call, onto the (already emptied) scene manager list.
        po->removeFromDirtyList();
        updateDirtyResource(item);
        hasSharedResources |= po->sharedResource;
        item = updateList;
    }
 
    if (hasSharedResources)
        res |= SyncResultFlag::SharedResourcesDirty;
 
    return res;
}
 
void QQuick3DSceneManager::updateNodes(QQuick3DObject **listHead)
{
    // Detach the current list head first, and consume all reachable entries.
    // New entries may be added to the new list while traversing, which will be
    // visited on the next updateDirtyNodes() call.
    QQuick3DObject *updateList = *listHead;
    *listHead = nullptr;
    if (updateList)
        QQuick3DObjectPrivate::get(updateList)->prevDirtyItem = &updateList;
 
    QQuick3DObject *item = updateList;
    while (item) {
        // Different processing for resource nodes vs hierarchical nodes (anything that's _not_ a resource)
        Q_ASSERT(QSSGRenderGraphObject::isNodeType(QQuick3DObjectPrivate::get(item)->type));
        // handle hierarchical nodes
        // See the matching comment in updateResources() about the removeFromDirtyList()/
        // updateSpatialNode() ordering.
        QQuick3DObjectPrivate::get(item)->removeFromDirtyList();
        updateDirtySpatialNode(static_cast<QQuick3DNode *>(item));
        item = updateList;
    }
}
 
QQuick3DSceneManager::SyncResult QQuick3DSceneManager::updateExtensions(QQuick3DObject **listHead)
{
    SyncResult ret = SyncResultFlag::None;
 
    const auto updateDirtyExtensionNode = [this, &ret](QQuick3DObject *extension) {
        QQuick3DObjectPrivate *po = QQuick3DObjectPrivate::get(extension);
        po->dirtyAttributes = 0; // Not used, but we should still reset it.
        QSSGRenderGraphObject *oldNode = po->spatialNode;
        QSSGRenderGraphObject *newNode = extension->updateSpatialNode(oldNode);
 
        const bool backendNodeChanged = oldNode != newNode;
 
        if (backendNodeChanged)
            ret |= SyncResultFlag::ExtensionsDiry;
 
        // If the backend node changed, we need to clean up the old one.
        if (oldNode && backendNodeChanged)
            cleanup(oldNode);
 
        // NOTE: cleanup() will remove the item from the node map and set the spatial node to nullptr.
        //       so we need to set it here.
        po->spatialNode = newNode;
 
        if (po->spatialNode)
            m_nodeMap.insert(po->spatialNode, extension);
 
        if (newNode && QSSGRenderGraphObjectUtils::hasInternalFlag(*newNode, QSSGRenderGraphObjectUtils::InternalFlags::AutoRegisterExtension)) {
            const bool shouldInsert = autoRegisteredExtensions.indexOf(static_cast<QSSGRenderExtension *>(newNode)) == -1;
            if (shouldInsert) {
                autoRegisteredExtensions.push_back(static_cast<QSSGRenderExtension *>(newNode));
                autoRegisteredExtensionsDirty = true;
            }
        }
    };
 
    // Detach the current list head first, and consume all reachable entries.
    // New entries may be added to the new list while traversing, which will be
    // visited on the next updateDirtyNodes() call.
    QQuick3DObject *updateList = *listHead;
    *listHead = nullptr;
    if (updateList)
        QQuick3DObjectPrivate::get(updateList)->prevDirtyItem = &updateList;
 
    QQuick3DObject *item = updateList;
    while (item) {
        // Different processing for resource nodes vs hierarchical nodes (anything that's _not_ a resource)
        Q_ASSERT(QSSGRenderGraphObject::isExtension(QQuick3DObjectPrivate::get(item)->type));
        // handle hierarchical nodes
        // See the matching comment in updateResources() about the removeFromDirtyList()/
        // updateSpatialNode() ordering.
        QQuick3DObjectPrivate::get(item)->removeFromDirtyList();
        updateDirtyExtensionNode(item);
        item = updateList;
    }
 
    return ret;
}
 
void QQuick3DSceneManager::preSync()
{
    for (auto it = std::begin(dirtyResources), end = std::end(dirtyResources); it != end; ++it) {
        QQuick3DObject *next = *it;
        while (next) {
            next->preSync();
            next = QQuick3DObjectPrivate::get(next)->nextDirtyItem;
        }
    }
 
    for (auto it = std::begin(dirtyNodes), end = std::end(dirtyNodes); it != end; ++it) {
        QQuick3DObject *next = *it;
        while (next) {
            next->preSync();
            next = QQuick3DObjectPrivate::get(next)->nextDirtyItem;
        }
    }
 
    for (auto it = std::begin(dirtyExtensions), end = std::end(dirtyExtensions); it != end; ++it) {
        QQuick3DObject *next = *it;
        while (next) {
            next->preSync();
            next = QQuick3DObjectPrivate::get(next)->nextDirtyItem;
        }
    }
}
 
////////
/// QQuick3DWindowAttachment
////////
 
QQuick3DWindowAttachment::QQuick3DWindowAttachment(QQuickWindow *window)
    : m_window(window)
    , m_rootNode(new QSSGRenderRoot)
{
    if (window) {
        // Act when the application calls window->releaseResources() and the
        // render loop emits the corresponding signal in order to forward the
        // event to us as well. (do not confuse with other release-resources
        // type of functions, this is about dropping pipeline and other resource
        // caches than can be automatically recreated if needed on the next frame)
        QQuickWindowPrivate *wd = QQuickWindowPrivate::get(window);
        QSGRenderContext *rc = wd->context;
        if (QSSG_GUARD_X(rc, "QQuickWindow has no QSGRenderContext, this should not happen")) {
            // QSGRenderContext signals are emitted on the render thread, if there is one; use DirectConnection
            connect(rc, &QSGRenderContext::releaseCachedResourcesRequested, this, &QQuick3DWindowAttachment::onReleaseCachedResources, Qt::DirectConnection);
            connect(rc, &QSGRenderContext::invalidated, this, &QQuick3DWindowAttachment::onInvalidated, Qt::DirectConnection);
        }
 
        // Do a final lifetime eval when the window is destroyed.
        connect(window, &QQuickWindow::destroyed, this, &QQuick3DWindowAttachment::evaluateEol);
        // afterAnimating is emitted on the main thread.
        connect(window, &QQuickWindow::afterAnimating, this, &QQuick3DWindowAttachment::preSync);
        // afterFrameEnd is emitted on render thread.
        connect(window, &QQuickWindow::afterFrameEnd, this, &QQuick3DWindowAttachment::cleanupResources, Qt::DirectConnection);
    }
}
 
QQuick3DWindowAttachment::~QQuick3DWindowAttachment()
{
    for (auto *manager : std::as_const(sceneManagerCleanupQueue)) {
        sceneManagers.removeOne(manager);
        delete manager;
    }
    // remaining sceneManagers should also be removed
    qDeleteAll(sceneManagers);
    QSSG_CHECK(QSSG_DEBUG_COND(resourceCleanupQueue.isEmpty()));
 
    if (!pendingResourceCleanupQueue.isEmpty()) {
        // Let's try to recover from this situation. Most likely this is some loader usage
        // situation, where all View3Ds have been destroyed while the window still lives and might
        // eventually just create a new View3D. We cannot release the resources here, as we'll need
        // to do that on the render thread. Instaed we'll transform the pendingResourceCleanupQueue
        // to a cleanup object that can be called on the render thread.
        if (m_rci && m_window) {
            new QSSGCleanupObject(m_rci, std::move(pendingResourceCleanupQueue), m_window);
            QMetaObject::invokeMethod(m_window, &QQuickWindow::releaseResources, Qt::QueuedConnection);
        } else {
            qWarning() << "Pending resource cleanup queue not empty, but no RCI or window to clean it up!";
        }
    }
 
    if (m_window)
        m_window->setProperty(qtQQ3DWAPropName, QVariant());
 
    delete m_rootNode;
}
 
void QQuick3DWindowAttachment::preSync()
{
    for (auto &sceneManager : std::as_const(sceneManagers))
        sceneManager->preSync();
}
 
// Called from the render thread
void QQuick3DWindowAttachment::cleanupResources()
{
    // Pass the scene managers list of resources marked for
    // removal to the render context for deletion
    // The render context will take ownership of the nodes
    // and clear the list
 
    // In special cases there is no rci because synchronize() is never called.
    // This can happen when running with the software backend of Qt Quick.
    // Handle this gracefully.
    if (!m_rci)
        return;
 
    // Check if there's orphaned resources that needs to be
    // cleaned out first.
    if (resourceCleanupQueue.size() != 0)
        m_rci->renderer()->cleanupResources(resourceCleanupQueue);
}
 
// Called on the render thread, if there is one
void QQuick3DWindowAttachment::onReleaseCachedResources()
{
    if (m_rci)
        m_rci->releaseCachedResources();
    Q_EMIT releaseCachedResources();
}
 
void QQuick3DWindowAttachment::onInvalidated()
{
    // Find all objects that have graphics resources and queue them
    // for cleanup.
    // 1. We'll need to manually go through the nodes of each scene manager and mark
    // objects with graphics resources for deletion.
    // The scene graph is invalidated so we need to release graphics resources now, on the render thread.
    for (auto &sceneManager : std::as_const(sceneManagers)) {
        const auto objects = sceneManager->m_nodeMap.keys();
        for (QSSGRenderGraphObject *obj : objects) {
            if (obj->hasGraphicsResources())
                sceneManager->cleanup(obj);
        }
    }
 
    // Start: follow the normal clean-up procedure
    for (auto &sceneManager : std::as_const(sceneManagers))
        sceneManager->cleanupNodes();
 
    for (QSSGRenderLayer *layers : std::as_const(pendingLayerCleanupQueue))
        delete layers;
    pendingLayerCleanupQueue.clear();
 
    for (const auto &pr : std::as_const(pendingResourceCleanupQueue))
        resourceCleanupQueue.insert(pr);
    pendingResourceCleanupQueue.clear();
 
    // NOTE!: It's essential that we release the cached resources before we
    // call cleanupResources(), to avoid the expensive bookkeeping code involved
    // for models. This is achieved by dropping the data to avoid expensive look-ups; it's going away anyways.
    // (In the future, if/when cleanupDrawCallData() is improved, then this step might not be necessary).
    onReleaseCachedResources();
 
    cleanupResources();
    // end
 
    // If the SG RenderContex is invalidated and we're the only one holding onto the SSG
    // RenderContextInterface then just release it. If the application is not going down
    // a new RCI will be created/set during the next sync.
    if (m_rci.use_count() == 1) {
        m_rci.reset();
        emit renderContextInterfaceChanged();
    }
}
 
QQuick3DWindowAttachment::SyncResult QQuick3DWindowAttachment::synchronize(QSet<QSSGRenderGraphObject *> &resourceLoaders)
{
    // Terminate old scene managers
    for (auto *manager : std::as_const(sceneManagerCleanupQueue)) {
        sceneManagers.removeOne(manager);
        delete manager;
    }
    // Terminate old scene managers
    sceneManagerCleanupQueue = {};
 
    SyncResult syncResult = SyncResultFlag::None;
 
    // Cleanup
    for (auto &sceneManager : std::as_const(sceneManagers))
        syncResult |= sceneManager->cleanupNodes();
 
    for (QSSGRenderLayer *layers : std::as_const(pendingLayerCleanupQueue))
        delete layers;
    pendingLayerCleanupQueue.clear();
 
    // Resources
    for (auto &sceneManager : std::as_const(sceneManagers))
        syncResult |= sceneManager->updateDirtyResourceNodes();
    // Spatial Nodes
    for (auto &sceneManager : std::as_const(sceneManagers))
        sceneManager->updateDirtySpatialNodes();
    for (auto &sceneManager : std::as_const(sceneManagers))
        syncResult |= sceneManager->updateDiryExtensions();
    for (auto &sceneManager : std::as_const(sceneManagers))
        syncResult |= sceneManager->updateDirtyResourceSecondPass();
    // Bounding Boxes
    for (auto &sceneManager : std::as_const(sceneManagers))
        sceneManager->updateBoundingBoxes(*m_rci->bufferManager());
    // Resource Loaders
    for (auto &sceneManager : std::as_const(sceneManagers))
        resourceLoaders.unite(sceneManager->resourceLoaders);
 
    if ((syncResult & SyncResultFlag::SharedResourcesDirty)) {
        // We know there are shared resources in the scene, so notify the "world".
        // Ideally we should be more targeted, but for now this will do the job.
        for (auto &sceneManager : std::as_const(sceneManagers))
            sceneManager->requestUpdate();
    }
 
    // Prepare pending (adopted) resources for clean-up (will happen as a result of afterFrameEnd()).
    for (const auto &pr : std::as_const(pendingResourceCleanupQueue))
        resourceCleanupQueue.insert(pr);
    pendingResourceCleanupQueue.clear();
 
    return syncResult;
}
 
void QQuick3DWindowAttachment::requestUpdate()
{
    for (const auto &sm : std::as_const(sceneManagers))
        sm->requestUpdate();
}
 
void QQuick3DWindowAttachment::evaluateEol()
{
    // NOTE: We'll re-iterate this list either on the next sync or if there's no sceneManagers left.
    // See: sync and dtor.
    for (QQuick3DSceneManager *manager : std::as_const(sceneManagerCleanupQueue))
        sceneManagers.removeOne(manager);
 
    // Keep the attachment, and the QSSGRenderRoot it owns, alive for as long as the window is,
    // even when no scene managers remain. Nodes reference the root via rootNodeRef (e.g. imported
    // scenes shared across views), and those references must stay valid across View3D create and
    // destroy cycles within the same window; deleting the root here would leave them dangling.
    // When the window goes away the attachment is deleted through the QQuickWindow::destroyed ->
    // evaluateEol connection set up in the constructor
    // (NOTE: QPointers are cleared out before the destroyed signal is sent).
    if (sceneManagers.isEmpty() && m_window.isNull())
        delete this;
}
 
QQuickWindow *QQuick3DWindowAttachment::window() const { return m_window; }
 
void QQuick3DWindowAttachment::setRci(const std::shared_ptr<QSSGRenderContextInterface> &rciptr)
{
    QSSG_CHECK_X(m_rci == nullptr || m_rci.use_count() == 1, "Old render context was not released!");
    m_rci = rciptr;
 
    // For convenience we'll also set the SG rendere context here.
    if (m_rci && m_window)
        QSSGRendererPrivate::setSgRenderContext(*m_rci->renderer(), QQuickWindowPrivate::get(m_window)->context);
 
    emit renderContextInterfaceChanged();
}
 
void QQuick3DWindowAttachment::registerSceneManager(QQuick3DSceneManager &manager)
{
    if (!sceneManagers.contains(&manager))
        sceneManagers.push_back(&manager);
}
 
void QQuick3DWindowAttachment::unregisterSceneManager(QQuick3DSceneManager &manager)
{
    sceneManagers.removeOne(&manager);
}
 
void QQuick3DWindowAttachment::queueForCleanup(QSSGRenderGraphObject *obj)
{
    Q_ASSERT(obj->hasGraphicsResources());
    pendingResourceCleanupQueue.push_back(obj);
}
 
void QQuick3DWindowAttachment::queueForCleanup(QQuick3DSceneManager *manager)
{
    if (!sceneManagerCleanupQueue.contains(manager))
        sceneManagerCleanupQueue.push_back(manager);
}
 
void QQuick3DWindowAttachment::queueForCleanup(QSSGRenderLayer *layer)
{
    if (QSSGRenderRoot *lr = QSSGRenderRoot::get(layer->rootNodeRef); lr != m_rootNode) {
        qWarning("Attempted to queue layer for cleanup that is not part of the current window!");
        return;
    }
 
    if (!pendingLayerCleanupQueue.contains(layer)) {
        layer->removeFromGraph();
        pendingLayerCleanupQueue.push_back(layer);
    }
}
 
QT_END_NAMESPACE