QSGNode Class

The QSGNode class is the base class for all nodes in the scene graph. More...

Header: #include <QSGNode>
qmake: QT += quick
Inherited By:

QSGBasicGeometryNode, QSGOpacityNode, and QSGTransformNode.

Public Types

flags DirtyState
enum DirtyStateBit { DirtyMatrix, DirtyNodeAdded, DirtyNodeRemoved, DirtyGeometry, DirtyMaterial, DirtyOpacity }
enum Flag { OwnedByParent, UsePreprocess, OwnsGeometry, OwnsMaterial, OwnsOpaqueMaterial, InternalReserved }
flags Flags
enum NodeType { BasicNodeType, GeometryNodeType, TransformNodeType, ClipNodeType, OpacityNodeType }

Public Functions

QSGNode()
virtual ~QSGNode()
void appendChildNode(QSGNode * node)
QSGNode * childAtIndex(int i) const
int childCount() const
QSGNode * firstChild() const
Flags flags() const
void insertChildNodeAfter(QSGNode * node, QSGNode * after)
void insertChildNodeBefore(QSGNode * node, QSGNode * before)
virtual bool isSubtreeBlocked() const
QSGNode * lastChild() const
void markDirty(DirtyState bits)
QSGNode * nextSibling() const
QSGNode * parent() const
void prependChildNode(QSGNode * node)
virtual void preprocess()
QSGNode * previousSibling() const
void removeAllChildNodes()
void removeChildNode(QSGNode * node)
void setFlag(Flag f, bool enabled = true)
void setFlags(Flags f, bool enabled = true)
NodeType type() const

Detailed Description

The QSGNode class is the base class for all nodes in the scene graph.

The QSGNode class can be used as a child container. Children are added with the appendChildNode(), prependChildNode(), insertChildNodeBefore() and insertChildNodeAfter(). The order of nodes is important as geometry nodes are rendered according to their ordering in the scene graph.

The scene graph nodes contains a mechanism to describe which parts of the scene has changed. This includes the combined matrices, accumulated opacity, changes to the node hierarchy, and so on. This information can be used for optimizations inside the scene graph renderer. For the renderer to properly render the nodes, it is important that users call QSGNode::markDirty() with the correct flags when nodes are changed. Most of the functions on the node classes will implicitly call markDirty(). For example, QSGNode::appendChildNode() will call markDirty() passing in QSGNode::DirtyNodeAdded.

If nodes change every frame, the preprocess() function can be used to apply changes to a node for every frame it is rendered. The use of preprocess() must be explicitly enabled by setting the QSGNode::UsePreprocess flag on the node.

The virtual isSubtreeBlocked() function can be used to disable a subtree all together. Nodes in a blocked subtree will not be preprocessed() and not rendered.

Note: All classes with QSG prefix should be used solely on the scene graph's rendering thread. See Scene Graph and Rendering for more information.

Member Type Documentation

enum QSGNode::​DirtyStateBit
flags QSGNode::​DirtyState

Used in QSGNode::markDirty() to indicate how the scene graph has changed.

ConstantValueDescription
QSGNode::DirtyMatrix0x0100The matrix in a QSGTransformNode has changed.
QSGNode::DirtyNodeAdded0x0400A node was added.
QSGNode::DirtyNodeRemoved0x0800A node was removed.
QSGNode::DirtyGeometry0x1000The geometry of a QSGGeometryNode has changed.
QSGNode::DirtyMaterial0x2000The material of a QSGGeometryNode has changed.
QSGNode::DirtyOpacity0x4000The opacity of a QSGOpacityNode has changed.

The DirtyState type is a typedef for QFlags<DirtyStateBit>. It stores an OR combination of DirtyStateBit values.

See also QSGNode::markDirty().

enum QSGNode::​Flag
flags QSGNode::​Flags

The QSGNode::Flag enum describes flags on the QSGNode

ConstantValueDescription
QSGNode::OwnedByParent0x0001The node is owned by its parent and will be deleted when the parent is deleted.
QSGNode::UsePreprocess0x0002The node's virtual preprocess() function will be called before rendering starts.
QSGNode::OwnsGeometry0x00010000Only valid for QSGGeometryNode and QSGClipNode. The node has ownership over the QSGGeometry instance and will delete it when the node is destroyed or a geometry is assigned.
QSGNode::OwnsMaterial0x00020000Only valid for QSGGeometryNode. The node has ownership over the material and will delete it when the node is destroyed or a material is assigned.
QSGNode::OwnsOpaqueMaterial0x00040000Only valid for QSGGeometryNode. The node has ownership over the opaque material and will delete it when the node is destroyed or a material is assigned.
QSGNode::InternalReserved0x01000000Reserved for internal use.

The Flags type is a typedef for QFlags<Flag>. It stores an OR combination of Flag values.

enum QSGNode::​NodeType

Can be used to figure out the type of node.

ConstantValueDescription
QSGNode::BasicNodeType0The type of QSGNode
QSGNode::GeometryNodeType1The type of QSGGeometryNode
QSGNode::TransformNodeType2The type of QSGTransformNode
QSGNode::ClipNodeType3The type of QSGClipNode
QSGNode::OpacityNodeType4The type of QSGOpacityNode

See also type().

Member Function Documentation

QSGNode::​QSGNode()

Constructs a new node

[virtual] QSGNode::​~QSGNode()

Destroys the node.

Every child of this node that has the flag QSGNode::OwnedByParent set, will also be deleted.

void QSGNode::​appendChildNode(QSGNode * node)

Appends node to this node's list of children.

Ordering of nodes is important as geometry nodes will be rendered in the order they are added to the scene graph.

QSGNode * QSGNode::​childAtIndex(int i) const

Returns the child at index i.

Children are stored internally as a linked list, so iterating over the children via the index is suboptimal.

int QSGNode::​childCount() const

Returns the number of child nodes.

QSGNode * QSGNode::​firstChild() const

Returns the first child of this node.

The children are stored in a linked list.

Flags QSGNode::​flags() const

Returns the set of flags for this node.

See also setFlags().

void QSGNode::​insertChildNodeAfter(QSGNode * node, QSGNode * after)

Inserts node to this node's list of children after the node specified with after.

Ordering of nodes is important as geometry nodes will be rendered in the order they are added to the scene graph.

void QSGNode::​insertChildNodeBefore(QSGNode * node, QSGNode * before)

Inserts node to this node's list of children before the node specified with before.

Ordering of nodes is important as geometry nodes will be rendered in the order they are added to the scene graph.

[virtual] bool QSGNode::​isSubtreeBlocked() const

Returns whether this node and its subtree is available for use.

Blocked subtrees will not get their dirty states updated and they will not be rendered.

The QSGOpacityNode will return a blocked subtree when accumulated opacity is 0, for instance.

QSGNode * QSGNode::​lastChild() const

Returns the last child of this node.

The children are stored as a linked list.

void QSGNode::​markDirty(DirtyState bits)

Notifies all connected renderers that the node has dirty bits.

QSGNode * QSGNode::​nextSibling() const

Returns the node after this in the parent's list of children.

The children are stored as a linked list.

QSGNode * QSGNode::​parent() const

Returns the parent node of this node.

void QSGNode::​prependChildNode(QSGNode * node)

Prepends node to this node's the list of children.

Ordering of nodes is important as geometry nodes will be rendered in the order they are added to the scene graph.

[virtual] void QSGNode::​preprocess()

Override this function to do processing on the node before it is rendered.

Preprocessing needs to be explicitly enabled by setting the flag QSGNode::UsePreprocess. The flag needs to be set before the node is added to the scene graph and will cause the preprocess() function to be called for every frame the node is rendered.

The preprocess function is called before the update pass that propegates opacity and transformations through the scene graph. That means that functions like QSGOpacityNode::combinedOpacity() and QSGTransformNode::combinedMatrix() will not contain up-to-date values. If such values are changed during the preprocess, these changes will be propegated through the scene graph before it is rendered.

Warning: Beware of deleting nodes while they are being preprocessed. It is possible, with a small performance hit, to delete a single node during its own preprocess call. Deleting a subtree which has nodes that also use preprocessing may result in a segmentation fault. This is done for performance reasons.

QSGNode * QSGNode::​previousSibling() const

Returns the node before this in the parent's list of children.

The children are stored as a linked list.

void QSGNode::​removeAllChildNodes()

Removes all child nodes from this node's list of children.

void QSGNode::​removeChildNode(QSGNode * node)

Removes node from this node's list of children.

void QSGNode::​setFlag(Flag f, bool enabled = true)

Sets the flag f on this node if enabled is true; otherwise clears the flag.

See also flags().

void QSGNode::​setFlags(Flags f, bool enabled = true)

Sets the flags f on this node if enabled is true; otherwise clears the flags.

See also flags().

NodeType QSGNode::​type() const

Returns the type of this node. The node type must be one of the predefined types defined in QSGNode::NodeType and can safely be used to cast to the corresponding class.

© 2015 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.