Revision control
Copy as Markdown
// Copyright (C) 2008-2012 NVIDIA Corporation.
// 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 "qssgrendernode_p.h"
#include <QtQuick3DRuntimeRender/private/qssglayerrenderdata_p.h>
#include <QtQuick3DUtils/private/qssgutils_p.h>
#include "qssgrendermodel_p.h"
#include "qssgrenderroot_p.h"
#include <QtQuick3DRuntimeRender/private/qssgrenderbuffermanager_p.h>
#include <QtQuick3DUtils/private/qssgplane_p.h>
QT_BEGIN_NAMESPACE
QSSGRenderNode::QSSGRenderNode()
: QSSGRenderNode(Type::Node)
{
}
QSSGRenderNode::QSSGRenderNode(Type type, QSSGRenderGraphObject::FlagT flags)
: QSSGRenderGraphObject(type, flags)
{
localTransform = calculateTransformMatrix({}, initScale, {}, {});
}
QSSGRenderNode::~QSSGRenderNode()
= default;
void QSSGRenderNode::markDirty(DirtyFlag dirtyFlag)
{
if ((flags & FlagT(dirtyFlag)) == 0) { // If not already marked
flags |= FlagT(dirtyFlag);
const bool markSubtreeDirty = ((FlagT(dirtyFlag) & FlagT(DirtyFlag::SubtreeUpdateMask)) != 0);
if (markSubtreeDirty) {
for (auto &child : children)
child.markDirty(dirtyFlag);
}
}
}
void QSSGRenderNode::clearDirty(DirtyFlag dirtyFlag)
{
flags &= ~FlagT(dirtyFlag);
}
void QSSGRenderNode::setState(LocalState state, bool on)
{
const bool changed = (getLocalState(state) != on);
if (changed) { // Mark state dirty
flags = on ? (flags | FlagT(state)) : (flags & ~FlagT(state));
// Mark state dirty
switch (state) {
case QSSGRenderNode::LocalState::Active:
markDirty(DirtyFlag::ActiveDirty);
break;
case QSSGRenderNode::LocalState::Pickable:
markDirty(DirtyFlag::PickableDirty);
break;
case QSSGRenderNode::LocalState::Imported:
markDirty(DirtyFlag::ImportDirty);
break;
}
}
}
QMatrix4x4 QSSGRenderNode::calculateTransformMatrix(QVector3D position, QVector3D scale, QVector3D pivot, QQuaternion rotation)
{
QMatrix4x4 transform;
// Offset the origin (this is our pivot point)
auto offset = (-pivot * scale);
// Scale
transform(0, 0) = scale[0];
transform(1, 1) = scale[1];
transform(2, 2) = scale[2];
// Offset (before rotation)
transform(0, 3) = offset[0];
transform(1, 3) = offset[1];
transform(2, 3) = offset[2];
// rotate
transform = QMatrix4x4{rotation.toRotationMatrix()} * transform;
// translate
transform(0, 3) += position[0];
transform(1, 3) += position[1];
transform(2, 3) += position[2];
return transform;
}
void QSSGRenderNode::addChild(QSSGRenderNode &inChild)
{
QSSG_ASSERT_X(inChild.parent != this, "Already a child of this node!", return);
// NOTE: A layer does not set a parent reference on its direct children.
// Those children (the View3D scene root, the ImportScene dummy, explicit cameras)
// are owned and kept alive by other subsystems, e.g. the scene root by the scene manager,
// so leaving their parent unset keeps the layer's lifetime decoupled from theirs (They can outlive the layer).
// Sharing of imported scenes is handled by the ImportScene dummy injected in
// QSSGRenderLayer::setImportScene().
if (type != QSSGRenderNode::Type::Layer) {
if (inChild.parent && inChild.parent != this)
inChild.parent->removeChild(inChild);
inChild.parent = this;
}
QSSG_ASSERT_X(type != QSSGRenderNode::Type::Root || inChild.type == QSSGRenderNode::Type::Layer,
"Only layers can be added to the root!", return);
if (inChild.type != QSSGRenderNode::Type::Root)
inChild.rootNodeRef = rootNodeRef;
// NOTE: We push importScene nodes to the front because this way we'll always index
// the imported scene first. This keeps their global index low and stable across
// views, so a shared imported scene can be placed at the start of a shared data store.
if (inChild.type != QSSGRenderNode::Type::ImportScene)
children.push_back(inChild);
else
children.push_front(inChild);
// Don't mark dirty if this is a layer, because layers won't have any global values
// calculated and therefore will not have the dirty flag cleared!
if (inChild.type != QSSGRenderNode::Type::Layer)
inChild.markDirty(DirtyFlag::GlobalValuesDirty);
if (QSSGRenderRoot *rootNode = QSSGRenderRoot::get(rootNodeRef))
rootNode->markDirty(QSSGRenderRoot::DirtyFlag::TreeDirty);
}
static inline bool isChildOfLayer(const QSSGRenderLayer &layer, const QSSGRenderNode &node)
{
// A layer does not set parent on its direct children (see addChild()), so the nodes parent
// cannot be used to validate relationship between the layer and the node.
// Instead we scan the children list to check if node is actually a child of this layer.
// We CANNOT dereference node at all! The renderer caches a raw pointer to the
// scene-manager-owned scene root and can call this during teardown after that node has been freed.
for (const auto &child : layer.children) {
if (&child == &node)
return true;
}
return false;
}
void QSSGRenderNode::removeChild(QSSGRenderNode &inChild)
{
if (type == QSSGRenderNode::Type::Layer) {
if (!isChildOfLayer(static_cast<const QSSGRenderLayer &>(*this), inChild))
return;
} else if (Q_UNLIKELY(inChild.parent != this)) {
Q_ASSERT(inChild.parent == this);
return;
}
inChild.parent = nullptr;
if (inChild.type != QSSGRenderNode::Type::Root)
inChild.rootNodeRef = nullptr;
inChild.h = {};
children.remove(inChild);
if (QSSGRenderRoot *rootNode = QSSGRenderRoot::get(rootNodeRef))
rootNode->markDirty(QSSGRenderRoot::DirtyFlag::TreeDirty);
inChild.markDirty(DirtyFlag::GlobalValuesDirty);
}
void QSSGRenderNode::removeFromGraph()
{
if (parent)
parent->removeChild(*this);
// Orphan all of my children.
for (auto it = children.begin(), end = children.end(); it != end;) {
auto &removedChild = *it++;
children.remove(removedChild);
removedChild.parent = nullptr;
removedChild.rootNodeRef = nullptr;
}
}
QSSGBounds3 QSSGRenderNode::getBounds(QSSGBufferManager &inManager,
bool inIncludeChildren) const
{
QSSGBounds3 retval;
if (inIncludeChildren)
retval = getChildBounds(inManager);
if (type == QSSGRenderGraphObject::Type::Model) {
auto model = static_cast<const QSSGRenderModel *>(this);
retval.include(inManager.getModelBounds(model));
}
return retval;
}
QSSGBounds3 QSSGRenderNode::getChildBounds(QSSGBufferManager &inManager) const
{
QSSGBounds3 retval;
QSSGBounds3 childBounds;
for (auto &child : children) {
childBounds = child.getBounds(inManager);
if (!childBounds.isEmpty()) {
// Transform the bounds into our local space.
childBounds.transform(child.localTransform);
retval.include(childBounds);
}
}
return retval;
}
QVector3D QSSGRenderNode::getDirection(const QMatrix4x4 &globalTransform)
{
const float *dataPtr(globalTransform.data());
QVector3D retval(dataPtr[8], dataPtr[9], dataPtr[10]);
retval.normalize();
return retval;
}
QVector3D QSSGRenderNode::getScalingCorrectDirection(const QMatrix4x4 &globalTransform)
{
QMatrix3x3 theDirMatrix = globalTransform.normalMatrix();
QVector3D theOriginalDir(0, 0, -1);
QVector3D retval = QSSGUtils::mat33::transform(theDirMatrix, theOriginalDir);
// Should already be normalized, but whatever
retval.normalize();
return retval;
}
void QSSGRenderNode::calculateMVP(const QMatrix4x4 &globalTransform, const QMatrix4x4 &inViewProjection, QMatrix4x4 &outMVP)
{
outMVP = inViewProjection * globalTransform;
}
void QSSGRenderNode::calculateNormalMatrix(const QMatrix4x4 &globalTransform, QMatrix3x3 &outNormalMatrix)
{
outNormalMatrix = globalTransform.normalMatrix();
}
void QSSGRenderNode::calculateMVPAndNormalMatrix(const QMatrix4x4 &globalTransform,
const QMatrix4x4 &inViewProjection,
QMatrix4x4 &outMVP,
QMatrix3x3 &outNormalMatrix)
{
calculateMVP(globalTransform, inViewProjection, outMVP);
calculateNormalMatrix(globalTransform, outNormalMatrix);
}
QT_END_NAMESPACE