Qt 3D C++ Classes
The Qt 3D module provides the foundations and core types used for near-realtime simulations built on the Qt 3D framework.
Namespaces
| Contains classes from the Qt3DAnimation module | |
| Contains classes from the Qt3DExtras module | |
| Contains classes that enable user input | |
| Contains classes used for implementing QML functionality into Qt3D applications | |
| Contains classes that enable 2D and 3D rendering | |
| Contains classes that are the foundation for Qt 3D simulation framework, as well as classes that provide the ability to render using the Qt 3D framework | |
| Contains classes that enable frame synchronization | 
Classes
Qt 3D Core Module
| The base class for aspects that provide a vertical slice of behavior | |
| Used to notify when a node is destroyed | |
| Base class for jobs executed in an aspect | |
| Base class for all Qt3D backend nodes | |
| Creates and maps backend nodes to their respective frontend nodes | |
| Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior | |
| A skeleton contains the joints for a skinned mesh | |
| Used to calculate skinning transform matrices and set them on shaders | |
| Used to transforms parts of skinned meshes | |
| Holds the data for a skeleton to be used with skinned meshes | |
| Environment for the QAspectEngine and a method for instantiating QML components | |
| Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene | |
| Used to notify when a component is added to an entity | |
| Used to notify when a component is removed from an entity | |
| Used to notify when a dynamic property value is updated | |
| The base class for all CommandRequested QSceneChange events | |
| Used to notify when a node is created | |
| The base class for all NodeCreated QSceneChange events | |
| Used to notify when a node is added to a property | |
| Used to notify when a node is removed from a property | |
| Used to notify when a property value is updated | |
| The base class for all PropertyUpdated QSceneChange events | |
| Used to notify when a value is added to a property | |
| The base class for all PropertyValueAdded QSceneChange events | |
| Used to notify when a value is added to a property | |
| The base class for all PropertyValueRemoved QSceneChange events | |
| Base class for changes that can be sent and received by Qt3D's change notification system | |
| The base class for all static PropertyUpdated QSceneChange events | |
| The base class for all static PropertyValueAdded QSceneChange events | |
| The base class for all static PropertyValueRemoved QSceneChange events | |
| Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component | |
| The base class of all Qt3D node classes used to build a Qt3D scene | |
| Uniquely identifies a QNode | |
| Used to load a skeleton of joints from file | |
| Used to perform transforms on meshes | 
Qt 3D Input Module
| The base class for the Action Input and all Aggregate Action Inputs | |
| QAbstractActionInput is the base class for all Axis Input | |
| Processes velocity or acceleration data from a QAxis | |
| Qt3DCore::QMouseEvent contains parameters that describe a mouse event | |
| Contains parameters that describe a mouse wheel event | |
| The base class used by Qt3d to interact with arbitrary input devices | |
| Links a set of QAbstractActionInput that trigger the same event | |
| Stores Device and Buttons used to trigger an input event | |
| An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystick | |
| Stores QAbstractAxisInputs used to trigger an input event | |
| Stores settings for the specified list of Axis | |
| An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystick | |
| Responsible for creating physical devices and handling associated jobs | |
| Represents a set of QAbstractActionInput's that must be triggerd at once | |
| Represents a set of QAbstractActionInput's that must be triggerd one after the other | |
| Holds the pointer to an input event source object | |
| In charge of dispatching keyboard events to attached QQKeyboardHandler objects | |
| Provides keyboard event notification | |
| Event type send by KeyBoardHandler | |
| Allows the user to define a set of actions that they wish to use within an application | |
| Delegates mouse events to the attached MouseHandler objects | |
| Provides a means of being notified about mouse events when attached to a QMouseDevice instance | |
| Base class for handling changes in physical devices | 
Qt 3D Logic Module
| Provides a way to have a synchronous function executed each frame | |
| Responsible for handling frame synchronization jobs | 
Qt 3D Render Module
| FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another | |
| Exchanges buffer data between GPU and CPU | |
| Class to allow for selection of camera to be used | |
| Class to clear buffers | |
| FrameGraph node to issue work for the compute shader on GPU | |
| Controls layers drawn in a frame graph branch | |
| Class to emplace a memory barrier | |
| Select entities which are within a distance threshold of a target entity | |
| Frame graph node for render capture | |
| Receives the result of render capture request | |
| Provides storage for the sort types to be used | |
| Abstract base class for all functors | |
| Way of controlling the complexity of rendered entities based on their size on the screen | |
| Specifies how entity picking is handled | |
| Holds settings related to rendering process and host the active FrameGraph | |
| Encapsulates a target (usually a frame buffer object) which the renderer can render into | |
| Defines an attribute and how data should be read from a QBuffer | |
| Provides a data store for raw data to later be used as vertices or uniforms | |
| Provides a mechanism to generate buffer data from a job | |
| Encapsulates geometry | |
| Encapsulates geometry rendering | |
| A custom mesh loader | |
| Provides the facility to load an existing Scene | |
| Encapsulate a QAbstractLight object in a Qt 3D scene | |
| Storage for filter keys and their values | |
| Identifies the API required for the attached QTechnique | |
| Provides storage for a name and value pair. This maps to a shader uniform | |
| Encapsulates a Render Pass | |
| Provides a way of specifying values of a Uniform Block or a shader structure | |
| Generates a Shader Program content from loaded graphs | |
| Encapsulates a Technique | |
| An abstract base class for ray casting in 3d scenes | |
| Holds information when an object is picked | |
| Specify alpha reference test | |
| Specifies the equation used for both the RGB blend equation and the Alpha blend equation | |
| Encapsulates blending information: specifies how the incoming values (what's going to be drawn) are going to affect the existing values (what is already drawn) | |
| Specifies whether front or back face culling is enabled | |
| Tests the fragment shader's depth value against the depth of a sample being written to | |
| Defines front and back facing polygons | |
| Specifies the width of rasterized lines | |
| Specifies the size of rasterized points. May either be set statically or by shader programs | |
| Sets the scale and steps to calculate depth values for polygon offsets | |
| Discards fragments that fall outside of a certain rectangular portion of the screen | |
| Controls the front and back writing of individual bits in the stencil planes | |
| Specifies stencil operation | |
| Sets the actions to be taken when stencil and depth tests fail | |
| Specifies arguments for the stecil test | |
| Specifies arguments for stencil test | |
| A base class to be used to provide textures | |
| Encapsulates the necessary information to create an OpenGL texture image | |
| A QAbstractTextureImage that can be written through a QPainter | |
| A QAbstractTexture with a Target1D target format | |
| A QAbstractTexture with a Target1DArray target format | |
| A QAbstractTexture with a Target2D target format | |
| A QAbstractTexture with a Target2DArray target format | |
| A QAbstractTexture with a Target2DMultisample target format | |
| A QAbstractTexture with a Target2DMultisampleArray target format | |
| A QAbstractTexture with a Target3D target format | |
| A QAbstractTexture with a TargetBuffer target format | |
| A QAbstractTexture with a TargetCubeMap target format | |
| A QAbstractTexture with a TargetCubeMapArray target format | |
| Handles the texture loading and setting the texture's properties | |
| A QAbstractTexture with a TargetRectangle target format | |
| Stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabled | |
| Provides the image data for a texture | |
| Base class of all FrameGraph configuration nodes | |
| A base class for changes in the FrameGraphNode | |
| Enable frustum culling for the FrameGraph | |
| When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive | |
| Provides storage for vectors of Filter Keys and Parameters | |
| FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branch | |
| Provides a way of specifying the render surface | |
| Provides a way of specifying a render target | |
| A QFrameGraphNode used to select QTechniques to use | |
| A viewport on the Qt3D Scene | |
| Defines a view point through which the scene will be rendered | |
| Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene | |
| QComponent to issue work for the compute shader on GPU | |
| Way of filtering which entities will be rendered | |
| Simple spherical volume, defined by its center and radius | |
| Provides a way of enabling child entities based on distance or screen size | |
| Allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... ) | |
| Encapsulate a Directional Light object in a Qt 3D scene | |
| Encapsulate an environment light object in a Qt 3D scene | |
| Encapsulate a Point Light object in a Qt 3D scene | |
| Encapsulate a Spot Light object in a Qt 3D scene | |
| Base class for effects in a Qt 3D scene | |
| Provides an abstract class that should be the base of all material component classes in a scene | |
| Encapsulates a Shader Program | |
| Instantiates a component that can be used to interact with a QEntity by a process known as picking | |
| Holds information when a segment of a line is picked | |
| Holds information when a segment of a point cloud is picked | |
| Holds information when a triangle is picked | |
| Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinates | |
| Details of a hit when casting a ray through a model | |
| Performe ray casting test based on screen coordinates | |
| Enable alpha-to-coverage multisampling mode | |
| Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance | |
| Allows specifying which color components should be written to the currently bound frame buffer | |
| Enable dithering | |
| Enable multisample antialiasing | |
| Disable depth write | |
| An abstract base class for all render states | |
| Enables seamless cubemap texture filtering | |
| Encapsulates the necessary information to create an OpenGL texture image from an image source | |
| Stores data representing a texture | |
| Provides texture image data for QAbstractTextureImage | |
| Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a texture | 
Qt 3D Extras Module
| Allows creation of a 3D extruded text in 3D space | |
| A 3D extruded Text mesh | |
| Basic functionality for camera controllers | |
| Default implementation of the phong lighting effect | |
| Allows controlling the scene camera from the first person perspective | |
| Default FrameGraph implementation of a forward renderer | |
| Material that implements the Gooch shading model, popular in CAD and CAM applications | |
| Default implementation of PBR lighting | |
| Default implementation of the phong lighting effect | |
| Allows controlling the scene camera along orbital path | |
| Default implementation for rendering the color properties set for each vertex | |
| Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene | |
| Default implementation of a simple unlit texture material | |
| Allows creation of a cone in 3D space. * * * * * The QConeGeometry class is most commonly used internally by the QConeMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses. The class * allows for creation of both a cone and a truncated cone | |
| A conical mesh | |
| Allows creation of a cuboid in 3D space. * * * * * The QCuboidGeometry class is most commonly used internally by the QCuboidMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses | |
| A cuboid mesh | |
| Allows creation of a cylinder in 3D space. * * * * * The QCylinderGeometry class is most commonly used internally by the QCylinderMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses | |
| A cylindrical mesh | |
| Allows creation of a plane in 3D space. * * * * * The QPlaneGeometry class is most commonly used internally by the QPlaneMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses | |
| A square planar mesh | |
| Allows creation of a sphere in 3D space. * * * * * The QSphereGeometry class is most commonly used internally by the QSphereMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses | |
| A spherical mesh | |
| Allows creation of a torus in 3D space. * * * * * The QTorusGeometry class is most commonly used internally by the QTorusMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses | |
| A toroidal mesh | 
Qt 3D Animation Module
| An abstract base class for Qt3D animations | |
| The base class for types providing key frame animation data | |
| The base class for types providing animation playback capabilities | |
| The base class for types used to construct animation blend trees | |
| Specifies key frame animation data | |
| Enables loading key frame animation data from a file | |
| Allows to map the channels within the clip onto an invocation of a callback object | |
| Class used for including a clip in a blend tree | |
| A class implementing blend-shape morphing animation | |
| A class implementing vertex-blend morphing animation | |
| Performs an additive blend of two animation clips based on an additive factor | |
| Provides key-frame animation capabilities to Qt 3D | |
| Class containing the animation data | |
| A controller class for animations | |
| A class grouping animations together | |
| Component providing animation playback capabilities of a tree of blend nodes | |
| Allows to map the channels within the clip onto properties of objects in the application | |
| Allows to map the channels within the clip onto properties of objects in the application | |
| Component providing simple animation playback capabilities | |
| A class implementing simple keyframe animation to a QTransform | |
| Performs a linear interpolation of two animation clips based on a normalized factor | |
| A class providing morph targets to blend-shape animation |