qssgrenderdata.cpp

++ // Copyright (C) 2025 The Qt Company Ltd.

++ // SPDX-License-Identifier: LicenseRef-Qt-Commercial OR GPL-3.0-only

++ // Qt-Security score:significant reason:default

++

++

++ #include "qssgrenderdata_p.h"

++

++ #if QT_CONFIG(thread)

++ #include <QtCore/qthreadpool.h>

++ #endif // QT_CONFIG(thread)

++

++ #include <QtCore/qtenvironmentvariables.h>

++

++ #include <QtQuick/private/qsgcontext_p.h>

++ #include <QtQuick/private/qsgrenderer_p.h>

++

++ #include "graphobjects/qssgrenderroot_p.h"

++ #include "graphobjects/qssgrenderlayer_p.h"

++ #include "graphobjects/qssgrenderitem2d_p.h"

++ #include "qssgrendercontextcore.h"

++ #include "qssgrenderer_p.h"

++ #include "resourcemanager/qssgrenderbuffermanager_p.h"

++

++ QT_BEGIN_NAMESPACE

++

++ Q_STATIC_LOGGING_CATEGORY(lcLayerData, "qt.quick3d.render.layerdata")

++

++ static void reindexChildNodes(QSSGRenderNode &node, const QSSGRenderNodeVersionType version, quint32 &dfsIdx, size_t &count)

++ {

++     Q_ASSERT(node.type != QSSGRenderNode::Type::Layer);

++     if (node.type != QSSGRenderNode::Type::Layer) {

++         // Note: In the case of import scenes the version and index might already

++         // have been set. We therefore assume nodes with same version is already

++         // indexed.

++         if (node.h.version() != version)

++             node.h = QSSGRenderNodeHandle(0, version, dfsIdx);

++         for (QSSGRenderNode &chld : node.children)

++             reindexChildNodes(chld, version, ++dfsIdx, ++count);

++     }

++ }

++

++ static void reindexLayerChildNodes(QSSGRenderLayer &layer, const QSSGRenderNodeVersionType version, quint32 &dfsIdx, size_t &count)

++ {

++     Q_ASSERT(layer.type == QSSGRenderNode::Type::Layer);

++     if (layer.type == QSSGRenderNode::Type::Layer) {

++         layer.h = QSSGRenderNodeHandle(0, version, 0); // Layer nodes are always indexed at 0;

++         for (QSSGRenderNode &chld : layer.children)

++             reindexChildNodes(chld, version, ++dfsIdx, ++count);

++     }

++ }

++

++ static void reindex(QSSGRenderRoot *rootNode, const QSSGRenderNodeVersionType version, quint32 &dfsIdx, size_t &count)

++ {

++     if (rootNode) {

++         Q_ASSERT(rootNode->type == QSSGRenderNode::Type::Root);

++         Q_ASSERT(dfsIdx == 0);

++         rootNode->h = QSSGRenderNodeHandle(0, version, 0);

++         for (QSSGRenderNode &chld : rootNode->children) // These should be layer nodes

++             reindexLayerChildNodes(static_cast<QSSGRenderLayer &>(chld), version, dfsIdx, count);

++     }

++ }

++

++ enum class Insert { Back, Indexed };

++ template <Insert insert = Insert::Back>

++ static void collectChildNodesFirst(QSSGRenderNode &node, QSSGGlobalRenderNodeData::NodeStore &outList, [[maybe_unused]] size_t &idx)

++ {

++     Q_ASSERT_X(node.type != QSSGRenderNode::Type::Layer, Q_FUNC_INFO, "Unexpected Layer node in child list!");

++     if constexpr (insert == Insert::Indexed)

++         outList[idx++] = &node;

++     else

++         outList.push_back(&node);

++     for (QSSGRenderNode &chld : node.children)

++         collectChildNodesFirst<insert>(chld, outList, idx);

++ }

++

++ template <Insert insert = Insert::Back>

++ static void collectChildNodesSecond(QSSGRenderNode &node, QSSGGlobalRenderNodeData::NodeStore &outList, [[maybe_unused]] size_t &idx)

++ {

++     if (node.getGlobalState(QSSGRenderNode::GlobalState::Active)) {

++         if constexpr (insert == Insert::Indexed)

++             outList[idx++] = &node;

++         else

++             outList.push_back(&node);

++         for (QSSGRenderNode &chld : node.children)

++             collectChildNodesSecond<insert>(chld, outList, idx);

++     }

++ }

++

++ enum class Discard { None, Inactive };

++ template <Discard discard = Discard::None, Insert insert = Insert::Back>

++ static void collectLayerChildNodes(QSSGRenderLayer *layer, QSSGGlobalRenderNodeData::NodeStore &outList, [[maybe_unused]] size_t &idx)

++ {

++     Q_ASSERT(layer->type == QSSGRenderNode::Type::Layer);

++     if (layer) {

++         for (QSSGRenderNode &chld : layer->children) {

++             if constexpr (discard == Discard::Inactive)

++                 collectChildNodesSecond<insert>(chld, outList, idx);

++             else

++                 collectChildNodesFirst<insert>(chld, outList, idx);

++         }

++     }

++

++     if  constexpr (insert == Insert::Back)

++         idx = outList.size();

++ }

++

++ template <QSSGRenderDataHelpers::Strategy Strategy>

++ static bool calcGlobalNodeDataIndexedImpl(QSSGRenderNode *node,

++                                           const QSSGRenderNodeVersionType version,

++                                           QSSGGlobalRenderNodeData::GlobalTransformStore &globalTransforms,

++                                           QSSGGlobalRenderNodeData::GlobalOpacityStore &globalOpacities)

++ {

++     using DirtyFlag = QSSGRenderNode::DirtyFlag;

++     using FlagT = QSSGRenderNode::FlagT;

++     constexpr DirtyFlag TransformAndOpacityDirty = DirtyFlag(FlagT(DirtyFlag::TransformDirty) | FlagT(DirtyFlag::OpacityDirty));

++

++     if (Q_UNLIKELY(!node || (node->h.version() != version)))

++         return false;

++

++     constexpr bool forcedRebuild = (Strategy == QSSGRenderDataHelpers::Strategy::Initial);

++     bool retval = forcedRebuild || node->isDirty(TransformAndOpacityDirty);

++

++     // NOTE 1: Nodes shared across windows will be marked with a stick dirty flag.

++     //         Officially this isn't supported, but in practice it can happen so

++     //         we try to be nice and try to keep things moving (literally).

++     // NOTE 2: We don't change the return value, as that would interfere with the progressive AA.

++     const bool alwaysDirty = node->isDirty(DirtyFlag::StickyDirty);

++

++     if (retval || alwaysDirty) {

++         const auto idx = node->h.index();

++

++         auto &globalTransform = globalTransforms[idx];

++         auto &globalOpacity = globalOpacities[idx];

++         globalOpacity = node->localOpacity;

++         globalTransform = node->localTransform;

++

++         if (QSSGRenderNode *parent = node->parent) {

++             const auto pidx = parent->h.index();

++             const auto pOpacity = globalOpacities[pidx];

++             globalOpacity *= pOpacity;

++

++             if (parent->type != QSSGRenderGraphObject::Type::Layer) {

++                 const auto pTransform = globalTransforms[pidx];

++                 globalTransform = pTransform * node->localTransform;

++             }

++         }

++         // Clear dirty flags (Transform, Opacity, Active, Pickable)

++         node->clearDirty(TransformAndOpacityDirty);

++     }

++

++     // We always clear dirty in a reasonable manner but if we aren't active

++     // there is no reason to tell the universe if we are dirty or not.

++     return retval;

++ }

++

++ QSSGRenderDataHelpers::GlobalStateResult QSSGRenderDataHelpers::updateGlobalNodeState(QSSGRenderNode *node, const VersionType version)

++ {

++     using LocalState = QSSGRenderNode::LocalState;

++     using GlobalState = QSSGRenderNode::GlobalState;

++     using DirtyFlag = QSSGRenderNode::DirtyFlag;

++     using FlagT = QSSGRenderNode::FlagT;

++

++     constexpr DirtyFlag ClearDirtyMask = DirtyFlag(FlagT(DirtyFlag::ActiveDirty) | FlagT(DirtyFlag::PickableDirty) | FlagT(DirtyFlag::ImportDirty));

++

++     constexpr GlobalStateResult activeChangeFlag[] = { GlobalStateResult::None, GlobalStateResult::ActiveChanged };

++     constexpr GlobalStateResult pickableChangeFlag[] = { GlobalStateResult::None, GlobalStateResult::PickableChanged };

++     constexpr GlobalStateResult tagChangeFlag[] = { GlobalStateResult::None, GlobalStateResult::TagChanged };

++

++     if (Q_UNLIKELY(!node || (node->h.version() != version)))

++         return GlobalStateResult::None;

++

++     const bool activeDirty = node->isDirty(DirtyFlag::ActiveDirty);

++     const bool pickableDirty = node->isDirty(DirtyFlag::PickableDirty);

++     const bool importedDirty = node->isDirty(DirtyFlag::ImportDirty);

++     // There's nothing more to do if the tag is dirty, but we still need to clear the dirty flag.

++     const bool tagDirty = node->isDirty(DirtyFlag::TagDirty);

++     node->clearDirty(DirtyFlag::TagDirty);

++

++     const bool updateState = activeDirty || pickableDirty || importedDirty;

++

++     if (updateState) {

++         const QSSGRenderNode *parent = node->parent;

++         const bool hasParent = (parent != nullptr);

++         const bool globallyActive = node->getLocalState(LocalState::Active) && (!hasParent || parent->getGlobalState(GlobalState::Active));

++         node->flags = globallyActive ? (node->flags | FlagT(GlobalState::Active)) : (node->flags & ~FlagT(GlobalState::Active));

++         const bool globallyPickable = node->getLocalState(LocalState::Pickable) || (hasParent && parent->getGlobalState(GlobalState::Pickable));

++         node->flags = globallyPickable ? (node->flags | FlagT(GlobalState::Pickable)) : (node->flags & ~FlagT(GlobalState::Pickable));

++         const bool globallyImported = node->getLocalState(LocalState::Imported) || (hasParent && parent->getGlobalState(GlobalState::Imported));

++         node->flags = globallyImported ? (node->flags | FlagT(GlobalState::Imported)) : (node->flags & ~FlagT(GlobalState::Imported));

++

++         // Clear dirty flags (Active, Pickable, Imported)

++         node->clearDirty(ClearDirtyMask);

++     }

++

++     return GlobalStateResult(FlagT(activeChangeFlag[activeDirty])

++                              | FlagT(pickableChangeFlag[pickableDirty])

++                              | FlagT(tagChangeFlag[tagDirty]));

++ }

++

++ bool QSSGRenderDataHelpers::calcInstanceTransforms(QSSGRenderNode *node,

++                                                    const VersionType version,

++                                                    QSSGGlobalRenderNodeData::GlobalTransformStore &globalTransforms,

++                                                    QSSGGlobalRenderNodeData::InstanceTransformStore &instanceTransforms)

++ {

++     if (Q_UNLIKELY(!node || (node->h.version() != version)))

++         return false;

++

++     constexpr bool retval = true;

++

++     // NOTE: We've already calculated the global states and transforms at this point

++     // so if the node isn't active we don't need to do anything.

++     // We're also assuming the node list is stored depth first order.

++     const auto idx = node->h.index();

++     QSSGRenderNode *parent = node->parent;

++     if (parent && parent->type != QSSGRenderGraphObject::Type::Layer && node->getLocalState(QSSGRenderNode::LocalState::Active)) {

++         const auto pidx = parent->h.index();

++         const auto &pGlobalTransform = globalTransforms[pidx];

++         QSSGRenderNode *instanceRoot = node->instanceRoot;

++         if (instanceRoot == node) {

++             instanceTransforms[idx] = { node->localTransform, pGlobalTransform };

++         } else if (instanceRoot) {

++             auto &[nodeInstanceLocalTransform, nodeInstanceGlobalTransform] = instanceTransforms[idx];

++             auto &[instanceRootLocalTransform, instanceRootGlobalTransform] = instanceTransforms[instanceRoot->h.index()];

++             nodeInstanceGlobalTransform = instanceRootGlobalTransform;

++             //### technically O(n^2) -- we could cache localInstanceTransform if every node in the

++             // tree is guaranteed to have the same instance root. That would require an API change.

++             nodeInstanceLocalTransform = node->localTransform;

++             auto *p = parent;

++             while (p) {

++                 if (p == instanceRoot) {

++                     nodeInstanceLocalTransform = instanceRootLocalTransform * nodeInstanceLocalTransform;

++                     break;

++                 }

++                 nodeInstanceLocalTransform = p->localTransform * nodeInstanceLocalTransform;

++                 p = p->parent;

++             }

++         } else {

++             // By default, we do magic: translation is applied to the global instance transform,

++             // while scale/rotation is local

++             QMatrix4x4 globalInstanceTransform = globalTransforms[pidx];

++             QMatrix4x4 localInstanceTransform = node->localTransform;

++             auto &localInstanceMatrix = *reinterpret_cast<float (*)[4][4]>(localInstanceTransform.data());

++             QVector3D localPos{localInstanceMatrix[3][0], localInstanceMatrix[3][1], localInstanceMatrix[3][2]};

++             localInstanceMatrix[3][0] = 0;

++             localInstanceMatrix[3][1] = 0;

++             localInstanceMatrix[3][2] = 0;

++             globalInstanceTransform = pGlobalTransform;

++             globalInstanceTransform.translate(localPos);

++             instanceTransforms[idx] = { localInstanceTransform, globalInstanceTransform };

++         }

++     } else {

++         instanceTransforms[idx] = { node->localTransform, {} };

++     }

++

++     return retval;

++ }

++

++ QSSGGlobalRenderNodeData::QSSGGlobalRenderNodeData(QSSGRenderRoot *root)

++ #if QT_CONFIG(thread) && !defined(Q_OS_WASM)

++     : m_threadPool(new QThreadPool)

++     , m_rootNode(root)

++ #else

++     : m_rootNode(root)

++ #endif // QT_CONFIG(thread)

++ {

++

++ }

++

++ QSSGGlobalRenderNodeData::~QSSGGlobalRenderNodeData()

++ {

++

++ }

++

++ void QSSGGlobalRenderNodeData::reindex()

++ {

++     if (m_rootNode) {

++         quint32 dfsIdx = 0;

++         m_nodeCount = 0;

++

++         // Bump the version to invalidate all existing handles. This ensures nodes don't start

++         // accessing stale data.

++         ++m_version;

++

++         // Version 0 means "not yet indexed" (default-constructed handle), so skip it.

++         // NOTE: This can happen if the version wraps around.

++         if (Q_UNLIKELY(m_version == 0)) {

++             qCDebug(lcLayerData) << "Version wrap around detected, resetting to 1.";

++             ++m_version;

++         }

++

++         ::reindex(m_rootNode, m_version, dfsIdx, m_nodeCount);

++

++         // Actual storage size (Some nodes, like the layers, will all use index 0).

++         // NOTE: This can differ from the node count, as nodes are collected for each

++         // layer. Since layers can reference nodes outside their view the node list

++         // will contain duplicate nodes when import scene is used!

++         m_size = dfsIdx + 1;

++

++         globalTransforms.resize(m_size, QMatrix4x4{ Qt::Uninitialized });

++         globalOpacities.resize(m_size, 1.0f);

++         instanceTransforms.resize(m_size, { QMatrix4x4{ Qt::Uninitialized }, QMatrix4x4{ Qt::Uninitialized } });

++         normalMatrices.resize(m_size, QMatrix3x3{});

++         meshes.resize(m_size, nullptr);

++         materials.resize(m_size, {});

++

++         collectNodes(m_rootNode);

++         // NOTE: If the tree was dirty we force a full rebuild of the global transforms etc. since

++         //       the stored data is invalid for the new index order.

++         updateGlobalState();

++     }

++ }

++

++ void QSSGGlobalRenderNodeData::invalidate()

++ {

++     m_rootNode = nullptr;

++ }

++

++ QMatrix4x4 QSSGGlobalRenderNodeData::getGlobalTransform(QSSGRenderNodeHandle h, const QMatrix4x4 &defaultValue) const

++ {

++     // Ensure we have an valid index.

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     // NOTE: In effect we are returning the local transform here in some cases, which

++     // is why we don't assert or have hints about the likelyhood of branching here.

++     if (!validVersion || !(globalTransforms.size() > index))

++         return defaultValue;

++

++     return globalTransforms[index];

++ }

++

++ QMatrix4x4 QSSGGlobalRenderNodeData::getGlobalTransform(QSSGRenderNodeHandle h) const

++ {

++     return getGlobalTransform(h, QMatrix4x4{ Qt::Uninitialized });

++ }

++

++ QMatrix4x4 QSSGGlobalRenderNodeData::getGlobalTransform(const QSSGRenderNode &node) const

++ {

++     return getGlobalTransform(node.h, node.localTransform);

++ }

++

++ float QSSGGlobalRenderNodeData::getGlobalOpacity(QSSGRenderNodeHandle h, float defaultValue) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     if (!validVersion || !(globalOpacities.size() > index))

++         return defaultValue;

++

++     return globalOpacities[index];

++ }

++

++ float QSSGGlobalRenderNodeData::getGlobalOpacity(const QSSGRenderNode &node) const

++ {

++     return getGlobalOpacity(node.h, node.localOpacity);

++ }

++

++ #if QT_CONFIG(thread)

++ #ifdef Q_OS_WASM

++ QThreadPool *QSSGGlobalRenderNodeData::threadPool() const { return nullptr; }

++ #else

++ QThreadPool *QSSGGlobalRenderNodeData::threadPool() const { return m_threadPool.get(); }

++ #endif

++ #endif // QT_CONFIG(thread)

++

++ QSSGGlobalRenderNodeData::LayerNodeView QSSGGlobalRenderNodeData::getLayerNodeView(QSSGRenderLayerHandle h) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     if (!validVersion || !(layerNodes.size() > index))

++         return { };

++

++     auto &section = layerNodes[index];

++

++     return { nodes.data() + section.offset, qsizetype(section.size) };

++ }

++

++ QSSGGlobalRenderNodeData::LayerNodeView QSSGGlobalRenderNodeData::getLayerNodeView(const QSSGRenderLayer &layer) const

++ {

++     return getLayerNodeView(layer.lh);

++ }

++

++ void QSSGGlobalRenderNodeData::collectNodes(QSSGRenderRoot *rootNode)

++ {

++     // 1. Collect all the nodes and create views into the node storage for each layer

++     // 2. Update the global state

++     // 3. Update the global data

++     Q_ASSERT(rootNode != nullptr);

++

++     nodes.clear();

++     nodes.resize(m_nodeCount, nullptr);

++     layerNodes.clear();

++

++     size_t idx = 0;

++     quint32 layerIdx = 0;

++     for (QSSGRenderNode &chld : rootNode->children) {

++         Q_ASSERT(chld.type == QSSGRenderNode::Type::Layer);

++         QSSGRenderLayer *layer = static_cast<QSSGRenderLayer *>(&chld);

++         const size_t offset = idx;

++         collectLayerChildNodes<Discard::None, Insert::Indexed>(layer, nodes, idx);

++         layer->lh = QSSGRenderLayerHandle(layer->h.context(), m_version, layerIdx++);

++         layerNodes.emplace_back(LayerNodeSection{offset , idx - offset});

++     }

++

++     nodes.resize(idx /* idx == next_idx == size */);

++ }

++

++ void QSSGGlobalRenderNodeData::updateGlobalState()

++ {

++     // Update the active and pickable state

++     for (QSSGRenderNode *node : nodes)

++         QSSGRenderDataHelpers::updateGlobalNodeState(node, m_version);

++

++     // Recalculate ALL the global transforms and opacities.

++     for (QSSGRenderNode *node : nodes)

++         calcGlobalNodeDataIndexedImpl<QSSGRenderDataHelpers::Strategy::Initial>(node, m_version, globalTransforms, globalOpacities);

++

++     // FIXME: We shouldn't need to re-create all the instance transforms even when instancing isn't used...

++     for (QSSGRenderNode *node : nodes)

++         QSSGRenderDataHelpers::calcInstanceTransforms(node, m_version, globalTransforms, instanceTransforms);

++ }

++

++ QSSGGlobalRenderNodeData::InstanceTransforms QSSGGlobalRenderNodeData::getInstanceTransforms(const QSSGRenderNode &node) const

++ {

++     return getInstanceTransforms(node.h);

++ }

++

++ QSSGGlobalRenderNodeData::InstanceTransforms QSSGGlobalRenderNodeData::getInstanceTransforms(QSSGRenderNodeHandle h) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     if (!validVersion || !(instanceTransforms.size() > index))

++         return { };

++

++     return instanceTransforms[index];

++ }

++

++ QSSGRenderModelData::QSSGRenderModelData(const QSSGGlobalRenderNodeDataPtr &globalNodeData)

++     : m_gnd(globalNodeData)

++     , m_version(globalNodeData->version())

++ {

++

++ }

++

++ QMatrix3x3 QSSGRenderModelData::getNormalMatrix(QSSGRenderNodeHandle h, QMatrix3x3 defaultValue) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_gnd->version());

++     const auto index = h.index();

++     if (!validVersion || !(m_gnd->normalMatrices.size() > index))

++         return defaultValue;

++

++     return m_gnd->normalMatrices[index];

++ }

++

++ QMatrix3x3 QSSGRenderModelData::getNormalMatrix(const QSSGRenderModel &model) const

++ {

++     return getNormalMatrix(model.h, QMatrix3x3{ Qt::Uninitialized });

++ }

++

++ QSSGRenderMesh *QSSGRenderModelData::getMesh(const QSSGRenderModel &model) const

++ {

++     const bool hasId = model.h.hasId();

++     const bool validVersion = hasId && (model.h.version() == m_gnd->version());

++     const auto index = model.h.index();

++

++     if (!validVersion || !(m_gnd->meshes.size() > index))

++         return nullptr;

++

++     return m_gnd->meshes[index];

++ }

++

++ QSSGRenderModelData::MaterialList QSSGRenderModelData::getMaterials(const QSSGRenderModel &model) const

++ {

++     const bool hasId = model.h.hasId();

++     const bool validVersion = hasId && (model.h.version() == m_gnd->version());

++     const auto index = model.h.index();

++

++     if (!validVersion || !(m_gnd->materials.size() > index))

++         return {};

++

++     return m_gnd->materials[index];

++ }

++

++ QSSGRenderModelData::ModelViewProjections QSSGRenderModelData::getModelViewProjection(const QSSGRenderModel &model) const

++ {

++     return getModelViewProjection(model.h);

++ }

++

++ QSSGRenderModelData::ModelViewProjections QSSGRenderModelData::getModelViewProjection(QSSGRenderNodeHandle h) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     if (!validVersion || !(modelViewProjections.size() > index))

++         return {};

++

++     return modelViewProjections[index];

++ }

++

++ void QSSGRenderModelData::prepareMeshData(const QSSGModelsView &models, QSSGRenderer *renderer)

++ {

++     const auto &bufferManager = renderer->contextInterface()->bufferManager();

++

++     const bool globalPickingEnabled = QSSGRendererPrivate::isGlobalPickingEnabled(*renderer);

++

++     for (auto *model : models) {

++         // It's up to the BufferManager to employ the appropriate caching mechanisms, so

++         // loadMesh() is expected to be fast if already loaded. Note that preparing

++         // the same QSSGRenderModel in different QQuickWindows (possible when a

++         // scene is shared between View3Ds where the View3Ds belong to different

++         // windows) leads to a different QSSGRenderMesh since the BufferManager is,

++         // very correctly, per window, and so per scenegraph render thread.

++

++         // Ensure we have a mesh

++         if (auto *theMesh = bufferManager->loadMesh(*model)) {

++             m_gnd->meshes[model->h.index()] = theMesh;

++             // Completely transparent models cannot be pickable.  But models with completely

++             // transparent materials still are.  This allows the artist to control pickability

++             // in a somewhat fine-grained style.

++             const float modelGlobalOpacity = m_gnd->getGlobalOpacity(*model);

++             const bool canModelBePickable = (modelGlobalOpacity > QSSGRendererPrivate::minimumRenderOpacity)

++                     && (globalPickingEnabled

++                         || model->getGlobalState(QSSGRenderModel::GlobalState::Pickable));

++             if (canModelBePickable) {

++                 // Check if there is BVH data, if not generate it

++                 if (!theMesh->bvh) {

++                     const QSSGMesh::Mesh mesh = bufferManager->loadLightmapMesh(*model);

++

++                     if (mesh.isValid())

++                         theMesh->bvh = bufferManager->loadMeshBVH(mesh);

++                     else if (model->geometry)

++                         theMesh->bvh = bufferManager->loadMeshBVH(model->geometry);

++                     else if (!model->meshPath.isNull())

++                         theMesh->bvh = bufferManager->loadMeshBVH(model->meshPath);

++

++                     if (theMesh->bvh) {

++                         const auto &roots = theMesh->bvh->roots();

++                         for (qsizetype i = 0, end = qsizetype(roots.size()); i < end; ++i)

++                             theMesh->subsets[i].bvhRoot = roots[i];

++                     }

++                 }

++             }

++         } else {

++             m_gnd->meshes[model->h.index()] = nullptr;

++         }

++     }

++

++     // Now is the time to kick off the vertex/index buffer updates for all the

++     // new meshes (and their submeshes). This here is the last possible place

++     // to kick this off because the rest of the rendering pipeline will only

++     // see the individual sub-objects as "renderable objects".

++     bufferManager->commitBufferResourceUpdates();

++ }

++

++ void QSSGRenderModelData::prepareMaterials(const QSSGModelsView &models)

++ {

++     for (auto *model : models)

++         m_gnd->materials[model->h.index()] = model->materials;

++ }

++

++ void QSSGRenderModelData::updateModelData(QSSGModelsView &models, QSSGRenderer *renderer, const QSSGRenderCameraDataList &renderCameraData)

++ {

++     const bool versionChanged = m_version != m_gnd->version();

++     if (versionChanged)

++         m_version = m_gnd->version();

++

++     const QMatrix4x4 defaultModelViewProjection;

++

++     // Resize per-layer MVP store to the GND storage size so import-scene shared nodes

++     // never alias each other's slots (GND indices are stable and unique across all layers).

++     modelViewProjections.resize(m_gnd->storageSize(), { defaultModelViewProjection, defaultModelViewProjection });

++

++ #if QT_CONFIG(thread)

++     QThreadPool *threadPool = (static_cast<size_t>(models.size()) >= m_threadPoolThreshold)

++                               ? m_gnd->threadPool() : nullptr;

++ #endif

++

++ #if QT_CONFIG(thread) && !defined(Q_OS_WASM)

++     bool matrixesDone = false;

++     bool mvpsDone = false;

++ #endif

++

++     // - Normal matrices (stored in GND, shared across layers)

++     const auto doNormalMatrices = [&]() {

++         for (const QSSGRenderModel *model : std::as_const(models)) {

++             auto &normalMatrix = m_gnd->normalMatrices[model->h.index()];

++             const QMatrix4x4 &globalTransform = m_gnd->globalTransforms[model->h.index()];

++             QSSGRenderNode::calculateNormalMatrix(globalTransform, normalMatrix);

++         }

++ #if QT_CONFIG(thread) && !defined(Q_OS_WASM)

++         if (threadPool) {

++             std::lock_guard<std::mutex> guard(m_mutex);

++             matrixesDone = true;

++             m_cv.notify_all();

++         }

++ #endif

++     };

++

++     // - MVPs (per-layer, indexed by GND node index)

++     const auto doMVPs = [&]() {

++         for (const QSSGRenderModel *model : std::as_const(models)) {

++             int mvpCount = 0;

++             const QMatrix4x4 &globalTransform = m_gnd->globalTransforms[model->h.index()];

++             auto &mvp = modelViewProjections[model->h.index()];

++             for (const QSSGRenderCameraData &cameraData : renderCameraData)

++                 QSSGRenderNode::calculateMVP(globalTransform, cameraData.viewProjection, mvp[mvpCount++]);

++         }

++ #if QT_CONFIG(thread) && !defined(Q_OS_WASM)

++         if (threadPool) {

++             std::lock_guard<std::mutex> guard(m_mutex);

++             mvpsDone = true;

++             m_cv.notify_all();

++         }

++ #endif

++     };

++

++ #if QT_CONFIG(thread)

++ #define qssgTryThreadedStart(func) \

++     if (!threadPool) { \

++         func(); \

++     } else if (!threadPool->tryStart(func)) { \

++         qWarning("Unable to start thread for %s!", #func); \

++         func(); \

++     }

++ #else

++ #define qssgTryThreadedStart(func) \

++     func();

++ #endif // QT_CONFIG(thread)

++

++     qssgTryThreadedStart(doNormalMatrices);

++     qssgTryThreadedStart(doMVPs);

++

++     // While we are waiting for the threads to finish, we can also prepare and update

++     // the materials and meshes.

++     prepareMaterials(models);

++     prepareMeshData(models, renderer);

++

++     // Wait for the threads to finish

++ #if QT_CONFIG(thread) && !defined(Q_OS_WASM)

++     if (threadPool) {

++         std::unique_lock<std::mutex> guard(m_mutex);

++         m_cv.wait(guard, [&]() { return matrixesDone && mvpsDone; });

++     }

++ #endif

++ }

++

++ quint32 QSSGRenderModelData::getThreadPoolThreshold()

++ {

++     // The threshold is the minimum number of models in a layer to consider using the thread pool for per-model calculations.

++     const int ret = qEnvironmentVariableIntValue("QSSG_MODEL_DATA_THREAD_POOL_THRESHOLD");

++     return (ret > 0) ? quint32(ret) : 32u;

++ }

++

++ bool QSSGRenderDataHelpers::updateGlobalNodeDataIndexed(QSSGRenderNode *node, const VersionType version, QSSGGlobalRenderNodeData::GlobalTransformStore &globalTransforms, QSSGGlobalRenderNodeData::GlobalOpacityStore &globalOpacities)

++ {

++     return calcGlobalNodeDataIndexedImpl<Strategy::Update>(node, version, globalTransforms, globalOpacities);

++ }

++

++ bool QSSGRenderDataHelpers::calcGlobalVariablesIndexed(QSSGRenderNode *node, const VersionType version, QSSGGlobalRenderNodeData::GlobalTransformStore &globalTransforms, QSSGGlobalRenderNodeData::GlobalOpacityStore &globalOpacities)

++ {

++     return calcGlobalNodeDataIndexedImpl<Strategy::Initial>(node, version, globalTransforms, globalOpacities);

++ }

++

++ QSSGRenderItem2DData::Item2DRenderer QSSGRenderItem2DData::getItem2DRenderer(const QSSGRenderItem2D &item) const

++ {

++     const auto foundIt = item2DRenderers.find(&item);

++     return (foundIt != item2DRenderers.cend()) ? foundIt->second : Item2DRenderer{};

++ }

++

++ QSSGRenderItem2DData::ModelViewProjections QSSGRenderItem2DData::getModelViewProjection(QSSGRenderNodeHandle h) const

++ {

++     const bool hasId = h.hasId();

++     const bool validVersion = hasId && (h.version() == m_version);

++     const auto index = h.index();

++

++     if (!validVersion || !(modelViewProjections.size() > index))

++         return {};

++

++     return modelViewProjections[index];

++ }

++

++ QSSGRenderItem2DData::ModelViewProjections QSSGRenderItem2DData::getModelViewProjection(const QSSGRenderItem2D &item) const

++ {

++     return getModelViewProjection(item.h);

++ }

++

++ QSSGRenderItem2DData::QSSGRenderItem2DData(const QSSGGlobalRenderNodeDataPtr &globalNodeData)

++ {

++     m_gnd = globalNodeData;

++     m_version = globalNodeData->version();

++ }

++

++ QSSGRenderItem2DData::~QSSGRenderItem2DData()

++ {

++     releaseAll();

++ }

++

++ void QSSGRenderItem2DData::updateItem2DData(QSSGItem2DsView &items, QSSGRenderer *renderer, const QSSGRenderCameraDataList &renderCameraData)

++ {

++     const auto itemCount = size_t(items.size());

++

++     if (itemCount == 0)

++         return;

++

++     const bool versionChanged = m_version != m_gnd->version();

++     if (versionChanged)

++         m_version = m_gnd->version();

++

++     const QMatrix4x4 defaultModelViewProjection;

++

++     const auto &rhiCtx = renderer->contextInterface()->rhiContext();

++

++     // Resize to GND storage size so import-scene shared nodes use their stable GND indices.

++     modelViewProjections.resize(m_gnd->storageSize(), { defaultModelViewProjection, defaultModelViewProjection });

++

++     const auto &clipSpaceCorrMatrix = rhiCtx->rhi()->clipSpaceCorrMatrix();

++

++     // - MVPs (indexed by GND node index)

++     const auto doMVPs = [&]() {

++         for (const QSSGRenderItem2D *item : std::as_const(items)) {

++             int mvpCount = 0;

++             const QMatrix4x4 &globalTransform = m_gnd->globalTransforms[item->h.index()];

++             auto &mvps = modelViewProjections[item->h.index()];

++             for (const QSSGRenderCameraData &cameraData : renderCameraData) {

++                 const QMatrix4x4 &mvp = cameraData.viewProjection * globalTransform;

++                 mvps[mvpCount++] = clipSpaceCorrMatrix * mvp * flipMatrix;

++             }

++         }

++     };

++

++     doMVPs();

++

++     // Check that we have a renderer and that it hasn't changed (would indicate a context change)

++     // and we need to update all the data.

++     QSGRenderContext *sgRc = QSSGRendererPrivate::getSgRenderContext(*renderer);

++     const bool contextChanged = (item2DRenderContext && item2DRenderContext != sgRc);

++     item2DRenderContext = sgRc;

++

++     for (const QSSGRenderItem2D *theItem2D : std::as_const(items)) {

++         auto item2DRenderer = getItem2DRenderer(*theItem2D);

++         if (contextChanged) {

++             delete item2DRenderer;

++             // NOTE: Should already be "cleared" as the QObject is deleted

++             // but we do it here for clarity.

++             item2DRenderer.clear();

++         }

++

++         if (!item2DRenderer) {

++             item2DRenderer = sgRc->createRenderer(QSGRendererInterface::RenderMode3D);

++             QObject::connect(item2DRenderer, SIGNAL(sceneGraphChanged()), theItem2D->m_frontEndObject, SLOT(update()));

++         }

++

++         if (item2DRenderer->rootNode() != theItem2D->m_rootNode) {

++             item2DRenderer->setRootNode(theItem2D->m_rootNode);

++             theItem2D->m_rootNode->markDirty(QSGNode::DirtyForceUpdate); // Force matrix, clip and opacity update.

++             item2DRenderer->nodeChanged(theItem2D->m_rootNode, QSGNode::DirtyForceUpdate); // Force render list update.

++         }

++

++         item2DRenderers[theItem2D] = item2DRenderer;

++     }

++ }

++

++ void QSSGRenderItem2DData::releaseRenderData(const QSSGRenderItem2D &item)

++ {

++     const auto foundIt = item2DRenderers.find(&item);

++     if (foundIt != item2DRenderers.cend()) {

++         delete foundIt->second;

++         item2DRenderers.erase(foundIt);

++

++         // Removing an item should trigger a reindex of the remaining items

++         ++m_version;

++     }

++ }

++

++ void QSSGRenderItem2DData::releaseAll()

++ {

++     for (auto &it : item2DRenderers)

++         delete it.second;

++     item2DRenderers.clear();

++     item2DRenderContext = nullptr;

++     modelViewProjections.clear();

++     m_version = 0;

++ }

++

++ QT_END_NAMESPACE

Revision control