qsgnode.cpp

Go to the documentation of this file.

// Copyright (C) 2016 The Qt Company Ltd.
// SPDX-License-Identifier: LicenseRef-Qt-Commercial OR LGPL-3.0-only OR GPL-2.0-only OR GPL-3.0-only
 
#include "qsgnode.h"
#include "qsgnode_p.h"
#include "qsgrenderer_p.h"
#include "qsgnodeupdater_p.h"
#include "qsgmaterial.h"
 
#include "limits.h"
 
QT_BEGIN_NAMESPACE
 
Q_DECLARE_LOGGING_CATEGORY(lcQsgLeak)
 
#ifndef QT_NO_DEBUG
static int qt_node_count = 0;
 
static void qt_print_node_count()
{
    qCDebug(lcQsgLeak, "Number of leaked nodes: %i", qt_node_count);
    qt_node_count = -1;
}
#endif
 
QSGNode::QSGNode()
    : m_nodeFlags(OwnedByParent)
{
    init();
}
 
QSGNode::QSGNode(NodeType type)
    : m_parent(nullptr)
    , m_type(type)
    , m_firstChild(nullptr)
    , m_lastChild(nullptr)
    , m_nextSibling(nullptr)
    , m_previousSibling(nullptr)
    , m_subtreeRenderableCount(type == GeometryNodeType || type == RenderNodeType ? 1 : 0)
    , m_nodeFlags(OwnedByParent)
{
    init();
}
 
QSGNode::QSGNode(QSGNodePrivate &dd, NodeType type)
    : m_parent(nullptr)
    , m_type(type)
    , m_firstChild(nullptr)
    , m_lastChild(nullptr)
    , m_nextSibling(nullptr)
    , m_previousSibling(nullptr)
    , m_subtreeRenderableCount(type == GeometryNodeType || type == RenderNodeType ? 1 : 0)
    , m_nodeFlags(OwnedByParent)
    , d_ptr(&dd)
{
    init();
}
 
void QSGNode::init()
{
#ifndef QT_NO_DEBUG
    if (lcQsgLeak().isDebugEnabled()) {
        ++qt_node_count;
        static bool atexit_registered = false;
        if (!atexit_registered) {
            atexit(qt_print_node_count);
            atexit_registered = true;
        }
    }
#endif
 
#ifdef QSG_RUNTIME_DESCRIPTION
    if (d_ptr.isNull())
        d_ptr.reset(new QSGNodePrivate());
#endif
}
 
QSGNode::~QSGNode()
{
#ifndef QT_NO_DEBUG
    if (lcQsgLeak().isDebugEnabled()) {
        --qt_node_count;
        if (qt_node_count < 0)
            qCDebug(lcQsgLeak, "Node destroyed after qt_print_node_count() was called.");
    }
#endif
    destroy();
}
 
 
bool QSGNode::isSubtreeBlocked() const
{
    return false;
}
 
void QSGNode::destroy()
{
    if (m_parent) {
        m_parent->removeChildNode(this);
        Q_ASSERT(m_parent == nullptr);
    }
    while (m_firstChild) {
        QSGNode *child = m_firstChild;
        removeChildNode(child);
        Q_ASSERT(child->m_parent == nullptr);
        if (child->flags() & OwnedByParent)
            delete child;
    }
 
    Q_ASSERT(m_firstChild == nullptr && m_lastChild == nullptr);
}
 
 
void QSGNode::prependChildNode(QSGNode *node)
{
    //Q_ASSERT_X(!m_children.contains(node), "QSGNode::prependChildNode", "QSGNode is already a child!");
    Q_ASSERT_X(!node->m_parent, "QSGNode::prependChildNode", "QSGNode already has a parent");
 
#ifndef QT_NO_DEBUG
    if (node->type() == QSGNode::GeometryNodeType) {
        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(node);
        Q_ASSERT_X(g->material(), "QSGNode::prependChildNode", "QSGGeometryNode is missing material");
        Q_ASSERT_X(g->geometry(), "QSGNode::prependChildNode", "QSGGeometryNode is missing geometry");
    }
#endif
 
    if (m_firstChild)
        m_firstChild->m_previousSibling = node;
    else
        m_lastChild = node;
    node->m_nextSibling = m_firstChild;
    m_firstChild = node;
    node->m_parent = this;
 
    node->markDirty(DirtyNodeAdded);
}
 
void QSGNode::appendChildNode(QSGNode *node)
{
    //Q_ASSERT_X(!m_children.contains(node), "QSGNode::appendChildNode", "QSGNode is already a child!");
    Q_ASSERT_X(!node->m_parent, "QSGNode::appendChildNode", "QSGNode already has a parent");
 
#ifndef QT_NO_DEBUG
    if (node->type() == QSGNode::GeometryNodeType) {
        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(node);
        Q_ASSERT_X(g->material(), "QSGNode::appendChildNode", "QSGGeometryNode is missing material");
        Q_ASSERT_X(g->geometry(), "QSGNode::appendChildNode", "QSGGeometryNode is missing geometry");
    }
#endif
 
    if (m_lastChild)
        m_lastChild->m_nextSibling = node;
    else
        m_firstChild = node;
    node->m_previousSibling = m_lastChild;
    m_lastChild = node;
    node->m_parent = this;
 
    node->markDirty(DirtyNodeAdded);
}
 
 
 
void QSGNode::insertChildNodeBefore(QSGNode *node, QSGNode *before)
{
    //Q_ASSERT_X(!m_children.contains(node), "QSGNode::insertChildNodeBefore", "QSGNode is already a child!");
    Q_ASSERT_X(!node->m_parent, "QSGNode::insertChildNodeBefore", "QSGNode already has a parent");
    Q_ASSERT_X(before && before->m_parent == this, "QSGNode::insertChildNodeBefore", "The parent of \'before\' is wrong");
 
#ifndef QT_NO_DEBUG
    if (node->type() == QSGNode::GeometryNodeType) {
        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(node);
        Q_ASSERT_X(g->material(), "QSGNode::insertChildNodeBefore", "QSGGeometryNode is missing material");
        Q_ASSERT_X(g->geometry(), "QSGNode::insertChildNodeBefore", "QSGGeometryNode is missing geometry");
    }
#endif
 
    QSGNode *previous = before->m_previousSibling;
    if (previous)
        previous->m_nextSibling = node;
    else
        m_firstChild = node;
    node->m_previousSibling = previous;
    node->m_nextSibling = before;
    before->m_previousSibling = node;
    node->m_parent = this;
 
    node->markDirty(DirtyNodeAdded);
}
 
 
 
void QSGNode::insertChildNodeAfter(QSGNode *node, QSGNode *after)
{
    //Q_ASSERT_X(!m_children.contains(node), "QSGNode::insertChildNodeAfter", "QSGNode is already a child!");
    Q_ASSERT_X(!node->m_parent, "QSGNode::insertChildNodeAfter", "QSGNode already has a parent");
    Q_ASSERT_X(after && after->m_parent == this, "QSGNode::insertChildNodeAfter", "The parent of \'after\' is wrong");
 
#ifndef QT_NO_DEBUG
    if (node->type() == QSGNode::GeometryNodeType) {
        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(node);
        Q_ASSERT_X(g->material(), "QSGNode::insertChildNodeAfter", "QSGGeometryNode is missing material");
        Q_ASSERT_X(g->geometry(), "QSGNode::insertChildNodeAfter", "QSGGeometryNode is missing geometry");
    }
#endif
 
    QSGNode *next = after->m_nextSibling;
    if (next)
        next->m_previousSibling = node;
    else
        m_lastChild = node;
    node->m_nextSibling = next;
    node->m_previousSibling = after;
    after->m_nextSibling = node;
    node->m_parent = this;
 
    node->markDirty(DirtyNodeAdded);
}
 
 
 
void QSGNode::removeChildNode(QSGNode *node)
{
    //Q_ASSERT(m_children.contains(node));
    Q_ASSERT(node->parent() == this);
 
    QSGNode *previous = node->m_previousSibling;
    QSGNode *next = node->m_nextSibling;
    if (previous)
        previous->m_nextSibling = next;
    else
        m_firstChild = next;
    if (next)
        next->m_previousSibling = previous;
    else
        m_lastChild = previous;
    node->m_previousSibling = nullptr;
    node->m_nextSibling = nullptr;
 
    node->markDirty(DirtyNodeRemoved);
    node->m_parent = nullptr;
}
 
 
void QSGNode::removeAllChildNodes()
{
    while (m_firstChild) {
        QSGNode *node = m_firstChild;
        m_firstChild = node->m_nextSibling;
        node->m_nextSibling = nullptr;
        if (m_firstChild)
            m_firstChild->m_previousSibling = nullptr;
        else
            m_lastChild = nullptr;
        node->markDirty(DirtyNodeRemoved);
        node->m_parent = nullptr;
    }
}
 
void QSGNode::reparentChildNodesTo(QSGNode *newParent)
{
    for (QSGNode *c = firstChild(); c; c = firstChild()) {
        removeChildNode(c);
        newParent->appendChildNode(c);
    }
}
 
 
int QSGNode::childCount() const
{
    int count = 0;
    QSGNode *n = m_firstChild;
    while (n) {
        ++count;
        n = n->m_nextSibling;
    }
    return count;
}
 
 
QSGNode *QSGNode::childAtIndex(int i) const
{
    QSGNode *n = m_firstChild;
    while (i && n) {
        --i;
        n = n->m_nextSibling;
    }
    return n;
}
 
 
void QSGNode::setFlag(Flag f, bool enabled)
{
    if (bool(m_nodeFlags & f) == enabled)
        return;
    m_nodeFlags ^= f;
    Q_ASSERT(int(UsePreprocess) == int(DirtyUsePreprocess));
    int changedFlag = f & UsePreprocess;
    if (changedFlag)
        markDirty(DirtyState(changedFlag));
}
 
 
void QSGNode::setFlags(Flags f, bool enabled)
{
    Flags oldFlags = m_nodeFlags;
    if (enabled)
        m_nodeFlags |= f;
    else
        m_nodeFlags &= ~f;
    Q_ASSERT(int(UsePreprocess) == int(DirtyUsePreprocess));
    int changedFlags = (oldFlags ^ m_nodeFlags) & UsePreprocess;
    if (changedFlags)
        markDirty(DirtyState(changedFlags));
}
 
 
 
void QSGNode::markDirty(DirtyState bits)
{
    int renderableCountDiff = 0;
    if (bits & DirtyNodeAdded)
        renderableCountDiff += m_subtreeRenderableCount;
    if (bits & DirtyNodeRemoved)
        renderableCountDiff -= m_subtreeRenderableCount;
 
    QSGNode *p = m_parent;
    while (p) {
        p->m_subtreeRenderableCount += renderableCountDiff;
        if (p->type() == RootNodeType)
            static_cast<QSGRootNode *>(p)->notifyNodeChange(this, bits);
        p = p->m_parent;
    }
}
 
void qsgnode_set_description(QSGNode *node, const QString &description)
{
#ifdef QSG_RUNTIME_DESCRIPTION
    QSGNodePrivate::setDescription(node, description);
#else
    Q_UNUSED(node);
    Q_UNUSED(description);
#endif
}
 
QSGBasicGeometryNode::QSGBasicGeometryNode(NodeType type)
    : QSGNode(type)
    , m_geometry(nullptr)
    , m_matrix(nullptr)
    , m_clip_list(nullptr)
{
}
 
 
QSGBasicGeometryNode::QSGBasicGeometryNode(QSGBasicGeometryNodePrivate &dd, NodeType type)
    : QSGNode(dd, type)
    , m_geometry(nullptr)
    , m_matrix(nullptr)
    , m_clip_list(nullptr)
{
}
 
 
QSGBasicGeometryNode::~QSGBasicGeometryNode()
{
    if (flags() & OwnsGeometry)
        delete m_geometry;
}
 
 
void QSGBasicGeometryNode::setGeometry(QSGGeometry *geometry)
{
    if ((flags() & OwnsGeometry) != 0 && m_geometry != geometry)
        delete m_geometry;
    m_geometry = geometry;
    markDirty(DirtyGeometry);
}
 
 
 
QSGGeometryNode::QSGGeometryNode()
    : QSGBasicGeometryNode(GeometryNodeType)
{
}
 
 
QSGGeometryNode::QSGGeometryNode(QSGGeometryNodePrivate &dd)
    : QSGBasicGeometryNode(dd, GeometryNodeType)
    , m_render_order(0)
    , m_material(nullptr)
    , m_opaque_material(nullptr)
    , m_opacity(1)
{
}
 
 
QSGGeometryNode::~QSGGeometryNode()
{
    if (flags() & OwnsMaterial)
        delete m_material;
    if (flags() & OwnsOpaqueMaterial)
        delete m_opaque_material;
}
 
 
 
void QSGGeometryNode::setRenderOrder(int order)
{
    m_render_order = order;
}
 
 
 
void QSGGeometryNode::setMaterial(QSGMaterial *material)
{
    if ((flags() & OwnsMaterial) != 0 && m_material != material)
        delete m_material;
    m_material = material;
#ifndef QT_NO_DEBUG
    if (m_material != nullptr && m_opaque_material == m_material)
        qWarning("QSGGeometryNode: using same material for both opaque and translucent");
#endif
    markDirty(DirtyMaterial);
}
 
 
 
void QSGGeometryNode::setOpaqueMaterial(QSGMaterial *material)
{
    if ((flags() & OwnsOpaqueMaterial) != 0 && m_opaque_material != m_material)
        delete m_opaque_material;
    m_opaque_material = material;
#ifndef QT_NO_DEBUG
    if (m_opaque_material != nullptr && m_opaque_material == m_material)
        qWarning("QSGGeometryNode: using same material for both opaque and translucent");
#endif
 
    markDirty(DirtyMaterial);
}
 
 
 
QSGMaterial *QSGGeometryNode::activeMaterial() const
{
    if (m_opaque_material && m_opacity > 0.999)
        return m_opaque_material;
    return m_material;
}
 
 
void QSGGeometryNode::setInheritedOpacity(qreal opacity)
{
    Q_ASSERT(opacity >= 0 && opacity <= 1);
    m_opacity = opacity;
}
 
 
QSGClipNode::QSGClipNode()
    : QSGBasicGeometryNode(ClipNodeType)
    , m_is_rectangular(false)
{
    Q_UNUSED(m_reserved);
}
 
 
 
QSGClipNode::~QSGClipNode()
{
}
 
 
 
void QSGClipNode::setIsRectangular(bool rectHint)
{
    m_is_rectangular = rectHint;
}
 
 
 
void QSGClipNode::setClipRect(const QRectF &rect)
{
    m_clip_rect = rect;
}
 
 
QSGTransformNode::QSGTransformNode()
    : QSGNode(TransformNodeType)
{
}
 
 
 
QSGTransformNode::~QSGTransformNode()
{
}
 
 
 
void QSGTransformNode::setMatrix(const QMatrix4x4 &matrix)
{
    m_matrix = matrix;
    markDirty(DirtyMatrix);
}
 
void QSGTransformNode::setCombinedMatrix(const QMatrix4x4 &matrix)
{
    m_combined_matrix = matrix;
}
 
 
 
QSGRootNode::QSGRootNode()
    : QSGNode(RootNodeType)
{
}
 
 
QSGRootNode::~QSGRootNode()
{
    while (!m_renderers.isEmpty())
        m_renderers.constLast()->setRootNode(nullptr);
    destroy(); // Must call destroy() here because markDirty() casts this to QSGRootNode.
}
 
 
 
void QSGRootNode::notifyNodeChange(QSGNode *node, DirtyState state)
{
    for (int i=0; i<m_renderers.size(); ++i) {
        m_renderers.at(i)->nodeChanged(node, state);
    }
}
 
 
 
QSGOpacityNode::QSGOpacityNode()
    : QSGNode(OpacityNodeType)
{
}
 
 
 
QSGOpacityNode::~QSGOpacityNode()
{
}
 
 
 
const qreal OPACITY_THRESHOLD = 0.001;
 
void QSGOpacityNode::setOpacity(qreal opacity)
{
    opacity = qBound<qreal>(0, opacity, 1);
    if (m_opacity == opacity)
        return;
    DirtyState dirtyState = DirtyOpacity;
 
    if ((m_opacity < OPACITY_THRESHOLD && opacity >= OPACITY_THRESHOLD)     // blocked to unblocked
        || (m_opacity >= OPACITY_THRESHOLD && opacity < OPACITY_THRESHOLD)) // unblocked to blocked
        dirtyState |= DirtySubtreeBlocked;
 
    m_opacity = opacity;
    markDirty(dirtyState);
}
 
 
 
void QSGOpacityNode::setCombinedOpacity(qreal opacity)
{
    m_combined_opacity = opacity;
}
 
 
 
bool QSGOpacityNode::isSubtreeBlocked() const
{
    return m_opacity < OPACITY_THRESHOLD;
}
 
 
QSGNodeVisitor::~QSGNodeVisitor()
{
 
}
 
 
void QSGNodeVisitor::visitNode(QSGNode *n)
{
    switch (n->type()) {
    case QSGNode::TransformNodeType: {
        QSGTransformNode *t = static_cast<QSGTransformNode *>(n);
        enterTransformNode(t);
        visitChildren(t);
        leaveTransformNode(t);
        break; }
    case QSGNode::GeometryNodeType: {
        QSGGeometryNode *g = static_cast<QSGGeometryNode *>(n);
        enterGeometryNode(g);
        visitChildren(g);
        leaveGeometryNode(g);
        break; }
    case QSGNode::ClipNodeType: {
        QSGClipNode *c = static_cast<QSGClipNode *>(n);
        enterClipNode(c);
        visitChildren(c);
        leaveClipNode(c);
        break; }
    case QSGNode::OpacityNodeType: {
        QSGOpacityNode *o = static_cast<QSGOpacityNode *>(n);
        enterOpacityNode(o);
        visitChildren(o);
        leaveOpacityNode(o);
        break; }
    default:
        visitChildren(n);
        break;
    }
}
 
void QSGNodeVisitor::visitChildren(QSGNode *n)
{
    for (QSGNode *c = n->firstChild(); c; c = c->nextSibling())
        visitNode(c);
}
 
#ifndef QT_NO_DEBUG_STREAM
QDebug operator<<(QDebug d, const QSGGeometryNode *n)
{
    if (!n) {
        d << "Geometry(null)";
        return d;
    }
    d << "GeometryNode(" << Qt::hex << (const void *) n << Qt::dec;
 
    const QSGGeometry *g = n->geometry();
 
    if (!g) {
        d << "no geometry";
    } else {
 
        switch (g->drawingMode()) {
        case QSGGeometry::DrawTriangleStrip: d << "strip"; break;
        case QSGGeometry::DrawTriangleFan: d << "fan"; break;
        case QSGGeometry::DrawTriangles: d << "triangles"; break;
        default: break;
        }
 
        d << "#V:" << g->vertexCount() << "#I:" << g->indexCount();
 
        if (g->attributeCount() > 0 && g->attributes()->type == QSGGeometry::FloatType) {
            float x1 = 1e10, x2 = -1e10, y1=1e10, y2=-1e10;
            int stride = g->sizeOfVertex();
            for (int i = 0; i < g->vertexCount(); ++i) {
                float x = ((float *)((char *)const_cast<QSGGeometry *>(g)->vertexData() + i * stride))[0];
                float y = ((float *)((char *)const_cast<QSGGeometry *>(g)->vertexData() + i * stride))[1];
 
                x1 = qMin(x1, x);
                x2 = qMax(x2, x);
                y1 = qMin(y1, y);
                y2 = qMax(y2, y);
            }
 
            d << "x1=" << x1 << "y1=" << y1 << "x2=" << x2 << "y2=" << y2;
        }
    }
 
    if (n->material())
        d << "materialtype=" << n->material()->type();
 
 
    d << ')';
#ifdef QSG_RUNTIME_DESCRIPTION
    d << QSGNodePrivate::description(n);
#endif
    return d;
}
 
QDebug operator<<(QDebug d, const QSGClipNode *n)
{
    if (!n) {
        d << "ClipNode(null)";
        return d;
    }
    d << "ClipNode(" << Qt::hex << (const void *) n << Qt::dec;
 
    if (n->childCount())
        d << "children=" << n->childCount();
 
    d << "is rect?" << (n->isRectangular() ? "yes" : "no");
 
    d << ')';
#ifdef QSG_RUNTIME_DESCRIPTION
    d << QSGNodePrivate::description(n);
#endif
    d << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
    return d;
}
 
QDebug operator<<(QDebug d, const QSGTransformNode *n)
{
    if (!n) {
        d << "TransformNode(null)";
        return d;
    }
    const QMatrix4x4 m = n->matrix();
    d << "TransformNode(";
    d << Qt::hex << (const void *) n << Qt::dec;
    if (m.isIdentity())
        d << "identity";
    else if (m.determinant() == 1 && m(0, 0) == 1 && m(1, 1) == 1 && m(2, 2) == 1)
        d << "translate" << m(0, 3) << m(1, 3) << m(2, 3);
    else
        d << "det=" << n->matrix().determinant();
#ifdef QSG_RUNTIME_DESCRIPTION
    d << QSGNodePrivate::description(n);
#endif
    d << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
    d << ')';
    return d;
}
 
QDebug operator<<(QDebug d, const QSGOpacityNode *n)
{
    if (!n) {
        d << "OpacityNode(null)";
        return d;
    }
    d << "OpacityNode(";
    d << Qt::hex << (const void *) n << Qt::dec;
    d << "opacity=" << n->opacity()
      << "combined=" << n->combinedOpacity()
      << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
#ifdef QSG_RUNTIME_DESCRIPTION
    d << QSGNodePrivate::description(n);
#endif
    d << ')';
    return d;
}
 
 
QDebug operator<<(QDebug d, const QSGRootNode *n)
{
    if (!n) {
        d << "RootNode(null)";
        return d;
    }
    QDebugStateSaver saver(d);
    d << "RootNode" << Qt::hex << (const void *) n << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
#ifdef QSG_RUNTIME_DESCRIPTION
    d << QSGNodePrivate::description(n);
#endif
    d << ')';
    return d;
}
 
 
 
QDebug operator<<(QDebug d, const QSGNode *n)
{
    if (!n) {
        d << "Node(null)";
        return d;
    }
    switch (n->type()) {
    case QSGNode::GeometryNodeType:
        d << static_cast<const QSGGeometryNode *>(n);
        break;
    case QSGNode::TransformNodeType:
        d << static_cast<const QSGTransformNode *>(n);
        break;
    case QSGNode::ClipNodeType:
        d << static_cast<const QSGClipNode *>(n);
        break;
    case QSGNode::RootNodeType:
        d << static_cast<const QSGRootNode *>(n);
        break;
    case QSGNode::OpacityNodeType:
        d << static_cast<const QSGOpacityNode *>(n);
        break;
    case QSGNode::RenderNodeType:
        d << "RenderNode(" << Qt::hex << (const void *) n << Qt::dec
          << "flags=" << (int) n->flags() << Qt::dec
          << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
#ifdef QSG_RUNTIME_DESCRIPTION
        d << QSGNodePrivate::description(n);
#endif
        d << ')';
        break;
    default:
        d << "Node(" << Qt::hex << (const void *) n << Qt::dec
          << "flags=" << (int) n->flags() << Qt::dec
          << (n->isSubtreeBlocked() ? "*BLOCKED*" : "");
#ifdef QSG_RUNTIME_DESCRIPTION
        d << QSGNodePrivate::description(n);
#endif
        d << ')';
        break;
    }
    return d;
}
 
#endif
 
QT_END_NAMESPACE