- Qt 6.11
- Qt Quick 3D
- QML Types
- Node
- Qt Quick 3D | Commercial or GPLv3

# Node QML Type

The base component for an object that exists in a 3D scene. More...

Import Statement: | `import QtQuick3D`
Inherits: | Object3D
Inherited By: | Affector3D, Attractor3D, AxisHelper, Camera, CustomCamera, DirectionalLight, FrustumCamera, Gravity3D, InstanceRepeater, Joint, Light, Loader3D, LodManager, LookAtNode, Model, OrthographicCamera, ParticleEmitter3D, ParticleSystem3D, PerspectiveCamera, PointLight, PointRotator3D, ReflectionProbe, Repeater3D, Repeller3D, RuntimeLoader, ScaleAffector3D, Skeleton, SpotLight, TrailEmitter3D, Wander3D, XrCamera, XrController, XrHandModel, XrItem, XrOrigin, and XrView

- List of all members, including inherited members

## Properties

- eulerRotation : vector3d
- forward : vector3d
- layers : int
- opacity : real
- pivot : vector3d
- position : vector3d
- right : vector3d
- rotation : quaternion
- scale : vector3d
- scenePosition : vector3d
- sceneRotation : quaternion
- sceneScale : vector3d
- sceneTransform : matrix4x4
- staticFlags : int
- up : vector3d
- visible : bool
- x : real
- y : real
- z : real

## Methods

- vector3d mapDirectionFromNode(QtQuick3D::Node node, vector3d localDirection)
- vector3d mapDirectionFromScene(vector3d sceneDirection)
- vector3d mapDirectionToNode(QtQuick3D::Node node, vector3d localDirection)
- vector3d mapDirectionToScene(vector3d localDirection)
- vector3d mapPositionFromNode(QtQuick3D::Node node, vector3d localPosition)
- vector3d mapPositionFromScene(vector3d scenePosition)
- vector3d mapPositionToNode(QtQuick3D::Node node, vector3d localPosition)
- vector3d mapPositionToScene(vector3d localPosition)
- rotate(real degrees, vector3d axis, enumeration space)

## Detailed Description

The Node type serves as the base class for other spatial types, such as, Model, Camera, Light. These objects represent an entity that exists in the 3D scene, due to having a position and other properties in the 3D world. With the exception of the root node(s), all Node types are transformed relative to their parent Node, that is, in local coordinates. In many ways the Node type serves the same purpose in Qt Quick 3D scenes as Item does for Qt Quick scenes.

In addition to types deriving from Node, it is also possible to parent other types to a Node. This includes QObject instances, where the Node merely serves as the QObject parent, and Qt Quick items.

Wrapping other objects for the purpose of grouping them into components or sub-trees can be a convenient way to, for example, animated a group of nodes as a whole. This snippet shows how to use Node to animate a camera:

     Node {
         PerspectiveCamera {
             position: Qt.vector3d(0, 0, -600)
         }

         SequentialAnimation on eulerRotation.y {
             loops: Animation.Infinite
             PropertyAnimation {
                 duration: 5000
                 from: 0
                 to: 360
             }
         }
     }

Node has to be used also if creating a scene outside of View3D, for example for the purpose of switching scenes on the fly, or showing the same scene on multiple views.

     Node {
         id: standAloneScene

         DirectionalLight {}

         Model {
             source: "#Sphere"
             materials: [ DefaultMaterial {} ]
         }

         PerspectiveCamera {
             z: 600
         }
     }

     View3D {
         importScene: standAloneScene
     }

## Property Documentation

### eulerRotation : vector3d

This property contains the rotation values for the x, y, and z axis. These values are stored as a vector3d. Rotation order is assumed to be ZXY.

See also QQuaternion::fromEulerAngles().

### forward : vector3d `[read-only]`

This property returns a normalized vector of the nodes forward direction in scene space.

See also up, right, and mapDirectionToScene.

### layers : int

This property defines the content layers that this node belongs to. The layers can be used to group nodes that belongs together, for example to be rendered together or to be filtered out from rendering. Setting this property on the active Camera will cause the camera to only render nodes that belong to the specified layers. The value is a bitmask, where each bit represents a layer.

By default nodes are assigned to the `main` layer, which is Layer0.

See also ContentLayer.

### opacity : real

This property contains the local opacity value of the Node. Since Node objects are not necessarily visible, this value might not have any effect, but this value is inherited by all children of the Node, which might be visible.

### pivot : vector3d

This property contains the pivot values for the x, y, and z axis. These values are used as the pivot points when applying rotations to the node.

### position : vector3d

This property contains the position translation in local coordinate space.

See also x, y, and z.

### right : vector3d `[read-only]`

This property returns a normalized vector of the nodes right direction in scene space.

See also forward, up, and mapDirectionToScene.

### rotation : quaternion

This property contains the rotation values for the node. These values are stored as a quaternion.

### scale : vector3d

This property contains the scale values for the x, y, and z axis.

### scenePosition : vector3d `[read-only]`

This property returns the position of the node in scene space.

Note: This is sometimes also referred to as the global position. But then in the meaning "global in the 3D world", and not "global to the screen or desktop" (which is usually the interpretation in other Qt APIs).

Note: the position will be reported in the same orientation as the node.

See also mapPositionToScene.

### sceneRotation : quaternion `[read-only]`

This property returns the rotation of the node in scene space.

### sceneScale : vector3d `[read-only]`

This property returns the scale of the node in scene space.

### sceneTransform : matrix4x4 `[read-only]`

This property returns the global transform matrix for this node.

Note: the return value will be in right-handed coordinates.

### staticFlags : int

This property defines the static flags that are used to evaluate how the node is rendered. Currently doesn't do anything but act as a placeholder for a future implementation.

### up : vector3d `[read-only]`

This property returns a normalized vector of the nodes up direction in scene space.

See also forward, right, and mapDirectionToScene.

### visible : bool

When this property is true, the Node (and its children) can be visible.

### x : real

This property contains the x value of the position translation in local coordinate space.

See also position.

### y : real

This property contains the y value of the position translation in local coordinate space.

See also position.

### z : real

This property contains the z value of the position translation in local coordinate space.

See also position.

## Method Documentation

### vector3d mapDirectionFromNode(QtQuick3D::Node node, vector3d localDirection)

Transforms localDirection from the local space of node to the local space of this node. The return value is not affected by the (inherited) scale or position of the node.

Note: the return value will have the same length as localDirection (i.e. not normalized).

Note: If node is null, then localDirection is interpreted as it is in scene space coordinates.

See also mapDirectionToNode, mapDirectionFromScene, and mapDirectionToScene.

### vector3d mapDirectionFromScene(vector3d sceneDirection)

Transforms sceneDirection from scene space to local space. The return value is not affected by the (inherited) scale or position of the node.

Note: the return value will have the same length as sceneDirection (i.e not normalized).

See also mapDirectionToScene, mapDirectionToNode, and mapDirectionFromNode.

### vector3d mapDirectionToNode(QtQuick3D::Node node, vector3d localDirection)

Transforms localDirection from this nodes local space to the local space of node. The return value is not affected by the (inherited) scale or position of the node.

Note: the return value will have the same length as localDirection (i.e. not normalized).

Note: if node is null, then the returned direction will be transformed into scene space coordinates.

See also mapDirectionFromNode, mapDirectionFromScene, and mapDirectionToScene.

### vector3d mapDirectionToScene(vector3d localDirection)

Transforms localDirection from local space to scene space. The return value is not affected by the (inherited) scale or position of the node.

Note: the return value will have the same length as localDirection (i.e. not normalized).

See also mapDirectionFromScene, mapDirectionToNode, and mapDirectionFromNode.

### vector3d mapPositionFromNode(QtQuick3D::Node node, vector3d localPosition)

Transforms localPosition from the local space of node to the local space of this node.

Note: If node is null, then localPosition is interpreted as it is in scene space coordinates.

See also mapPositionToScene, mapPositionFromScene, and mapPositionToNode.

### vector3d mapPositionFromScene(vector3d scenePosition)

Transforms scenePosition from scene space to local space.

See also mapPositionToScene, mapPositionToNode, and mapPositionFromNode.

### vector3d mapPositionToNode(QtQuick3D::Node node, vector3d localPosition)

Transforms localPosition from the local space of this node to the local space of node.

Note: If node is null, then localPosition will be transformed into scene space coordinates.

See also mapPositionToScene, mapPositionFromScene, and mapPositionFromNode.

### vector3d mapPositionToScene(vector3d localPosition)

Transforms localPosition from local space to scene space.

Note: "Scene space" is sometimes also referred to as the "global space". But then in the meaning "global in the 3D world", and not "global to the screen or desktop" (which is usually the interpretation in other Qt APIs).

See also mapPositionFromScene, mapPositionToNode, and mapPositionFromNode.

### rotate(real degrees, vector3d axis, enumeration space)

Rotates this node around an axis by the given degrees. The specified rotation will be added to the node's current rotation. The axis can be specified relative to different spaces.

Constant | Description
--- | ---
`Node.LocalSpace` | Axis is relative to the local orientation of this node.
`Node.ParentSpace` | Axis is relative to the local orientation of the parent node.
`Node.SceneSpace` | Axis is relative to the scene.