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 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 from the Qt3DExtras module |
|
Contains classes that enable 2D and 3D rendering |
|
Contains classes that enable user input |
|
Contains classes that enable frame synchronization |
Classes
Qt 3D Core Module
The base class for aspects that provide a vertical slice of behavior |
|
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 |
|
Used to notify when a node is created |
|
The base class for all NodeCreated QSceneChange events |
|
Used to notify when a node is destroyed |
|
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 for jobs executed in an aspect |
|
Base class for all Qt3D backend nodes |
|
Creates and maps backend nodes to their respective frontend nodes |
|
Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component |
|
Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior |
|
The base class of all Qt3D node classes used to build a Qt3D scene |
|
Uniquely identifies a QNode |
|
Used to perform transforms on meshes |
|
Environment for the QAspectEngine and a method for instantiating QML components |
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 |
|
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 |
|
Processes velocity or acceleration data from a QAxis |
|
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 |
|
Qt3DCore::QMouseEvent contains parameters that describe a mouse event |
|
Contains parameters that describe a mouse wheel event |
|
Provides a means of being notified about mouse events when attached to a QMouseDevice instance |
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
Provides a generic way of loading various 3D assets format into a Qt3D scene |
|
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 |
|
Base class of all FrameGraph configuration nodes |
|
A base class for changes in the FrameGraphNode |
|
Enable frustum culling for the FrameGraph |
|
Controls layers Drawn in a frame graph branch |
|
Class to emplace a memory barrier |
|
When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive |
|
Frame graph node for render capture |
|
Receives the result of render capture request |
|
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 |
|
Provides storage for the sort types to be used |
|
A QFrameGraphNode used to select QTechniques to use |
|
A viewport on the Qt3D Scene |
|
Abstract base class for all functors |
|
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 |
|
Way of controlling the complexity of rendered entities based on their size on the screen |
|
Simple spherical volume, defined by it's center and radius |
|
Provides a way of enabling child entities based on distance or screen size |
|
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 |
|
Allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... ) |
|
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 |
|
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 |
|
Storage for filter keys and their values |
|
Identifies the API required for the attached QTechnique |
|
Provides an abstract class that should be the base of all material component classes in a scene |
|
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 |
|
Encapsulates a Shader Program |
|
Encapsulates a Technique |
|
Instantiates a component that can be used to interact with a QEntity by a process known as picking |
|
Holds information when an object is picked |
|
Holds information when a triangle is picked |
|
Enable alpha-to-coverage multisampling mode |
|
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) |
|
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 |
|
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 |
|
Enable dithering |
|
Defines front and back facing polygons |
|
Enable multisample antialiasing |
|
Disable depth write |
|
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 |
|
An abstract base class for all render states |
|
Discards fragments that fall outside of a certain rectangular portion of the screen |
|
Enables seamless cubemap texture filtering |
|
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 |
|
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 |
|
Default implementation of the phong lighting effect where the diffuse light component is read from a texture map |
|
Default implementation of the phong lighting effect where the diffuse and specular light components are read from texture maps |
|
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 |
|
Specialization of QNormalDiffuseMapMaterial with alpha coverage and a depth test performed in the rendering pass |
|
Default implementation of the phong lighting and bump effect where the diffuse light component is read from a texture map and the normals of the mesh being rendered from a normal texture map |
|
Default implementation of the phong lighting and bump effect where the diffuse and specular light components are read from texture maps and the normals of the mesh being rendered from a normal texture map |
|
Allows controlling the scene camera along orbital path |
|
Default implementation for rendering the color properties set for each vertex |
|
Default implementation of the phong lighting effect with alpha |
|
Default implementation of the phong lighting effect |
|
Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene |
|
Default implementation of PBR lighting, environment maps and bump effect where the components are read from texture maps (including normal maps) |
|
Default implementation of a simple unlit texture material |
|
Allows creation of a cone in 3D space |
|
A conical mesh |
|
Allows creation of a cuboid in 3D space |
|
A cuboid mesh |
|
Allows creation of a cylinder in 3D space |
|
A cylindrical mesh |
|
Allows creation of a plane in 3D space |
|
A square planar mesh |
|
Allows creation of a sphere in 3D space |
|
A spherical mesh |
|
Allows creation of a torus in 3D space |
|
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 |
|
Performs an additive blend of two animation clips based on an additive factor |
|
Provides key-frame animation capabilities to Qt 3D |
|
A controller class for animations |
|
A class grouping animations together |
|
Component providing animation playback capabilities of a tree of blend nodes |
|
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 implementing blend-shape morphing animation |
|
A class providing morph targets to blend-shape animation |
|
A class implementing vertex-blend morphing animation |
Qt 3D Scene2D Module
This class enables rendering qml into a texture, which then can be used as a part of 3D scene |
© The Qt Company Ltd
Licensed under the GNU Free Documentation License, Version 1.3.
https://doc.qt.io/qt-5.9/qt3d-cpp.html