Qt 3D C++ Classes | Qt 3D | Qt 6.11.2
Description: The Qt 3D module contains functionality to support near-realtime simulation systems.

- Qt 6.11
- Qt 3D
- Qt 3D C++ Classes
- Qt 6.11.2 Reference Documentation

# 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

Qt3DAnimation | Contains classes from the Qt3DAnimation module
Qt3DCore | 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
Qt3DCore::Quick | Contains classes used for implementing QML functionality into Qt3D applications
Qt3DExtras | Contains classes from the Qt3DExtras module
Qt3DInput | Contains classes that enable user input
Qt3DLogic | Contains classes that enable frame synchronization
Qt3DRender | Contains classes that enable 2D and 3D rendering

## Classes

### Qt 3D Core Module

Qt3DCore::QAbstractAspect | The base class for aspects that provide a vertical slice of behavior
Qt3DCore::QAbstractFunctor | Abstract base class for all functors
Qt3DCore::QAbstractSkeleton | A skeleton contains the joints for a skinned mesh
Qt3DCore::QArmature | Used to calculate skinning transform matrices and set them on shaders
Qt3DCore::QAspectEngine | Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene
Qt3DCore::QAspectJob | Base class for jobs executed in an aspect
Qt3DCore::QAttribute | Defines an attribute and how data should be read from a QBuffer
Qt3DCore::QBackendNode | Base class for all Qt3D backend nodes
Qt3DCore::QBackendNodeMapper | Creates and maps backend nodes to their respective frontend nodes
Qt3DCore::QBoundingVolume | Can be used to override the bounding volume of an entity
Qt3DCore::QBuffer | Provides a data store for raw data to later be used as vertices or uniforms
Qt3DCore::QComponent | Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component
Qt3DCore::QCoreSettings | Holds settings related to core data handling process
Qt3DCore::QEntity | Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior
Qt3DCore::QGeometry | Encapsulates geometry
Qt3DCore::QGeometryView | Encapsulates geometry details
Qt3DCore::QJoint | Used to transforms parts of skinned meshes
Qt3DCore::QNode | The base class of all Qt3D node classes used to build a Qt3D scene
Qt3DCore::QNodeId | Uniquely identifies a QNode
Qt3DCore::QSkeleton | Holds the data for a skeleton to be used with skinned meshes
Qt3DCore::QSkeletonLoader | Used to load a skeleton of joints from file
Qt3DCore::QTransform | Used to perform transforms on meshes
Qt3DCore::Quick::QQmlAspectEngine | Environment for the QAspectEngine and a method for instantiating QML components

### Qt 3D Input Module

Qt3DInput::QAbstractActionInput | The base class for the Action Input and all Aggregate Action Inputs
Qt3DInput::QAbstractAxisInput | QAbstractActionInput is the base class for all Axis Input
Qt3DInput::QAbstractPhysicalDevice | The base class used by Qt3d to interact with arbitrary input devices
Qt3DInput::QAction | Links a set of QAbstractActionInput that trigger the same event
Qt3DInput::QActionInput | Stores Device and Buttons used to trigger an input event
Qt3DInput::QAnalogAxisInput | An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystick
Qt3DInput::QAxis | Stores QAbstractAxisInputs used to trigger an input event
Qt3DInput::QAxisAccumulator | Processes velocity or acceleration data from a QAxis
Qt3DInput::QAxisSetting | Stores settings for the specified list of Axis
Qt3DInput::QButtonAxisInput | An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystick
Qt3DInput::QInputAspect | Responsible for creating physical devices and handling associated jobs
Qt3DInput::QInputChord | Represents a set of QAbstractActionInput's that must be triggerd at once
Qt3DInput::QInputSequence | Represents a set of QAbstractActionInput's that must be triggerd one after the other
Qt3DInput::QInputSettings | Holds the pointer to an input event source object
Qt3DInput::QKeyEvent | Event type send by KeyBoardHandler
Qt3DInput::QKeyboardDevice | In charge of dispatching keyboard events to attached QQKeyboardHandler objects
Qt3DInput::QKeyboardHandler | Provides keyboard event notification
Qt3DInput::QLogicalDevice | Allows the user to define a set of actions that they wish to use within an application
Qt3DInput::QMouseDevice | Delegates mouse events to the attached MouseHandler objects
Qt3DInput::QMouseEvent | Qt3DCore::QMouseEvent contains parameters that describe a mouse event
Qt3DInput::QMouseHandler | Provides a means of being notified about mouse events when attached to a QMouseDevice instance
Qt3DInput::QWheelEvent | Contains parameters that describe a mouse wheel event

### Qt 3D Logic Module

Qt3DLogic::QFrameAction | Provides a way to have a synchronous function executed each frame
Qt3DLogic::QLogicAspect | Responsible for handling frame synchronization jobs

### Qt 3D Render Module

Qt3DRender::QAbstractLight | Encapsulate a QAbstractLight object in a Qt 3D scene
Qt3DRender::QAbstractRayCaster | An abstract base class for ray casting in 3d scenes
Qt3DRender::QAbstractTexture | A base class to be used to provide textures
Qt3DRender::QAbstractTextureImage | Encapsulates the necessary information to create an OpenGL texture image
Qt3DRender::QAlphaCoverage | Enable alpha-to-coverage multisampling mode
Qt3DRender::QAlphaTest | Specify alpha reference test
Qt3DRender::QBlendEquation | Specifies the equation used for both the RGB blend equation and the Alpha blend equation
Qt3DRender::QBlendEquationArguments | 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)
Qt3DRender::QBlitFramebuffer | FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another
Qt3DRender::QBufferCapture | Exchanges buffer data between GPU and CPU
Qt3DRender::QCamera | Defines a view point through which the scene will be rendered
Qt3DRender::QCameraLens | Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene
Qt3DRender::QCameraSelector | Class to allow for selection of camera to be used
Qt3DRender::QClearBuffers | Class to clear buffers
Qt3DRender::QClipPlane | Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance
Qt3DRender::QColorMask | Allows specifying which color components should be written to the currently bound frame buffer
Qt3DRender::QComputeCommand | QComponent to issue work for the compute shader on GPU
Qt3DRender::QCullFace | Specifies whether front or back face culling is enabled
Qt3DRender::QDebugOverlay | Enables a visual overlay with scene details
Qt3DRender::QDepthRange | Enables remapping depth values written into the depth buffer
Qt3DRender::QDepthTest | Tests the fragment shader's depth value against the depth of a sample being written to
Qt3DRender::QDirectionalLight | Encapsulate a Directional Light object in a Qt 3D scene
Qt3DRender::QDispatchCompute | FrameGraph node to issue work for the compute shader on GPU
Qt3DRender::QDithering | Enable dithering
Qt3DRender::QEffect | Base class for effects in a Qt 3D scene
Qt3DRender::QEnvironmentLight | Encapsulate an environment light object in a Qt 3D scene
Qt3DRender::QFilterKey | Storage for filter keys and their values
Qt3DRender::QFrameGraphNode | Base class of all FrameGraph configuration nodes
Qt3DRender::QFrontFace | Defines front and back facing polygons
Qt3DRender::QFrustumCulling | Enable frustum culling for the FrameGraph
Qt3DRender::QGeometryRenderer | Encapsulates geometry rendering
Qt3DRender::QGraphicsApiFilter | Identifies the API required for the attached QTechnique
Qt3DRender::QLayer | Way of filtering which entities will be rendered
Qt3DRender::QLayerFilter | Controls layers drawn in a frame graph branch
Qt3DRender::QLevelOfDetail | Way of controlling the complexity of rendered entities based on their size on the screen
Qt3DRender::QLevelOfDetailBoundingSphere | Simple spherical volume, defined by its center and radius
Qt3DRender::QLevelOfDetailSwitch | Provides a way of enabling child entities based on distance or screen size
Qt3DRender::QLineWidth | Specifies the width of rasterized lines
Qt3DRender::QMaterial | Provides an abstract class that should be the base of all material component classes in a scene
Qt3DRender::QMemoryBarrier | Class to emplace a memory barrier
Qt3DRender::QMesh | A custom mesh loader
Qt3DRender::QMultiSampleAntiAliasing | Enable multisample antialiasing
Qt3DRender::QNoDepthMask | Disable depth write
Qt3DRender::QNoDraw | When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive
Qt3DRender::QNoPicking | When a Qt3DRender::QNoPicking node is present in a FrameGraph branch, this prevents the render aspect from performing picking selection for the given branch
Qt3DRender::QObjectPicker | Instantiates a component that can be used to interact with a QEntity by a process known as picking
Qt3DRender::QPaintedTextureImage | A QAbstractTextureImage that can be written through a QPainter
Qt3DRender::QParameter | Provides storage for a name and value pair. This maps to a shader uniform
Qt3DRender::QPickEvent | Holds information when an object is picked
Qt3DRender::QPickLineEvent | Holds information when a segment of a line is picked
Qt3DRender::QPickPointEvent | Holds information when a segment of a point cloud is picked
Qt3DRender::QPickTriangleEvent | Holds information when a triangle is picked
Qt3DRender::QPickingProxy | Can be used to provide an alternate QGeometryView used only for picking
Qt3DRender::QPickingSettings | Specifies how entity picking is handled
Qt3DRender::QPointLight | Encapsulate a Point Light object in a Qt 3D scene
Qt3DRender::QPointSize | Specifies the size of rasterized points. May either be set statically or by shader programs
Qt3DRender::QPolygonOffset | Sets the scale and steps to calculate depth values for polygon offsets
Qt3DRender::QProximityFilter | Select entities which are within a distance threshold of a target entity
Qt3DRender::QRasterMode | Render state allows to control the type of rasterization to be performed
Qt3DRender::QRayCaster | Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinates
Qt3DRender::QRayCasterHit | Details of a hit when casting a ray through a model
Qt3DRender::QRenderAspect | Class
Qt3DRender::QRenderCapabilities | Holds settings related to available rendering engines
Qt3DRender::QRenderCapture | Frame graph node for render capture
Qt3DRender::QRenderCaptureReply | Receives the result of render capture request
Qt3DRender::QRenderPass | Encapsulates a Render Pass
Qt3DRender::QRenderPassFilter | Provides storage for vectors of Filter Keys and Parameters
Qt3DRender::QRenderSettings | Holds settings related to rendering process and host the active FrameGraph
Qt3DRender::QRenderState | An abstract base class for all render states
Qt3DRender::QRenderStateSet | FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branch
Qt3DRender::QRenderSurfaceSelector | Provides a way of specifying the render surface
Qt3DRender::QRenderTarget | Encapsulates a target (usually a frame buffer object) which the renderer can render into
Qt3DRender::QRenderTargetOutput | Allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... )
Qt3DRender::QRenderTargetSelector | Provides a way of specifying a render target
Qt3DRender::QSceneLoader | Provides the facility to load an existing Scene
Qt3DRender::QScissorTest | Discards fragments that fall outside of a certain rectangular portion of the screen
Qt3DRender::QScreenRayCaster | Performe ray casting test based on screen coordinates
Qt3DRender::QSeamlessCubemap | Enables seamless cubemap texture filtering
Qt3DRender::QSetFence | FrameGraphNode used to insert a fence in the graphics command stream
Qt3DRender::QShaderData | Provides a way of specifying values of a Uniform Block or a shader structure
Qt3DRender::QShaderImage | Provides Image access to shader programs
Qt3DRender::QShaderProgram | Encapsulates a Shader Program
Qt3DRender::QShaderProgramBuilder | Generates a Shader Program content from loaded graphs
Qt3DRender::QSharedGLTexture | Allows to use a textureId from a separate OpenGL context in a Qt 3D scene
Qt3DRender::QSortPolicy | Provides storage for the sort types to be used
Qt3DRender::QSpotLight | Encapsulate a Spot Light object in a Qt 3D scene
Qt3DRender::QStencilMask | Controls the front and back writing of individual bits in the stencil planes
Qt3DRender::QStencilOperation | Specifies stencil operation
Qt3DRender::QStencilOperationArguments | Sets the actions to be taken when stencil and depth tests fail
Qt3DRender::QStencilTest | Specifies arguments for the stecil test
Qt3DRender::QStencilTestArguments | Specifies arguments for stencil test
Qt3DRender::QSubtreeEnabler | Enables or disables entire subtrees of framegraph nodes
Qt3DRender::QTechnique | Encapsulates a Technique
Qt3DRender::QTechniqueFilter | A QFrameGraphNode used to select QTechniques to use
Qt3DRender::QTexture1D | A QAbstractTexture with a Target1D target format
Qt3DRender::QTexture1DArray | A QAbstractTexture with a Target1DArray target format
Qt3DRender::QTexture2D | A QAbstractTexture with a Target2D target format
Qt3DRender::QTexture2DArray | A QAbstractTexture with a Target2DArray target format
Qt3DRender::QTexture2DMultisample | A QAbstractTexture with a Target2DMultisample target format
Qt3DRender::QTexture2DMultisampleArray | A QAbstractTexture with a Target2DMultisampleArray target format
Qt3DRender::QTexture3D | A QAbstractTexture with a Target3D target format
Qt3DRender::QTextureBuffer | A QAbstractTexture with a TargetBuffer target format
Qt3DRender::QTextureCubeMap | A QAbstractTexture with a TargetCubeMap target format
Qt3DRender::QTextureCubeMapArray | A QAbstractTexture with a TargetCubeMapArray target format
Qt3DRender::QTextureData | Stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabled
Qt3DRender::QTextureDataUpdate | Holds content and information required to perform partial updates of a texture content
Qt3DRender::QTextureImage | Encapsulates the necessary information to create an OpenGL texture image from an image source
Qt3DRender::QTextureImageData | Stores data representing a texture
Qt3DRender::QTextureImageDataGenerator | Provides texture image data for QAbstractTextureImage
Qt3DRender::QTextureLoader | Handles the texture loading and setting the texture's properties
Qt3DRender::QTextureRectangle | A QAbstractTexture with a TargetRectangle target format
Qt3DRender::QTextureWrapMode | Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a texture
Qt3DRender::QViewport | A viewport on the Qt3D Scene
Qt3DRender::QWaitFence | FrameGraphNode used to wait for a fence in the graphics command stream to become signaled

### Qt 3D Extras Module

Qt3DExtras::QAbstractCameraController | Basic functionality for camera controllers
Qt3DExtras::QConeGeometry | Allows creation of a cone in 3D space
Qt3DExtras::QConeGeometryView | A conical mesh
Qt3DExtras::QConeMesh | A conical mesh
Qt3DExtras::QCuboidGeometry | Allows creation of a cuboid in 3D space
Qt3DExtras::QCuboidGeometryView | A cuboid mesh
Qt3DExtras::QCuboidMesh | A cuboid mesh
Qt3DExtras::QCylinderGeometry | Allows creation of a cylinder in 3D space
Qt3DExtras::QCylinderGeometryView | A cylindrical mesh
Qt3DExtras::QCylinderMesh | A cylindrical mesh
Qt3DExtras::QDiffuseSpecularMaterial | Default implementation of the phong lighting effect
Qt3DExtras::QExtrudedTextGeometry | Allows creation of a 3D extruded text in 3D space
Qt3DExtras::QExtrudedTextMesh | A 3D extruded Text mesh
Qt3DExtras::QFirstPersonCameraController | Allows controlling the scene camera from the first person perspective
Qt3DExtras::QForwardRenderer | Default FrameGraph implementation of a forward renderer
Qt3DExtras::QGoochMaterial | Material that implements the Gooch shading model, popular in CAD and CAM applications
Qt3DExtras::QMetalRoughMaterial | Default implementation of PBR lighting
Qt3DExtras::QMorphPhongMaterial | Default implementation of the phong lighting effect
Qt3DExtras::QOrbitCameraController | Allows controlling the scene camera along orbital path
Qt3DExtras::QPerVertexColorMaterial | Default implementation for rendering the color properties set for each vertex
Qt3DExtras::QPlaneGeometry | Allows creation of a plane in 3D space
Qt3DExtras::QPlaneGeometryView | A square planar mesh
Qt3DExtras::QPlaneMesh | A square planar mesh
Qt3DExtras::QSkyboxEntity | Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene
Qt3DExtras::QSphereGeometry | Allows creation of a sphere in 3D space
Qt3DExtras::QSphereGeometryView | A spherical mesh
Qt3DExtras::QSphereMesh | A spherical mesh
Qt3DExtras::QText2DEntity | Allows creation of a 2D text in 3D space
Qt3DExtras::QTextureMaterial | Default implementation of a simple unlit texture material
Qt3DExtras::QTorusGeometry | Allows creation of a torus in 3D space
Qt3DExtras::QTorusGeometryView | A toroidal mesh
Qt3DExtras::QTorusMesh | A toroidal mesh

### Qt 3D Animation Module

Qt3DAnimation::QAbstractAnimation | An abstract base class for Qt3D animations
Qt3DAnimation::QAbstractAnimationClip | The base class for types providing key frame animation data
Qt3DAnimation::QAbstractClipAnimator | The base class for types providing animation playback capabilities
Qt3DAnimation::QAbstractClipBlendNode | The base class for types used to construct animation blend trees
Qt3DAnimation::QAdditiveClipBlend | Performs an additive blend of two animation clips based on an additive factor
Qt3DAnimation::QAnimationAspect | Provides key-frame animation capabilities to Qt 3D
Qt3DAnimation::QAnimationCallback | Represents an animation callback object
Qt3DAnimation::QAnimationClip | Specifies key frame animation data
Qt3DAnimation::QAnimationClipData | Class containing the animation data
Qt3DAnimation::QAnimationClipLoader | Enables loading key frame animation data from a file
Qt3DAnimation::QAnimationController | A controller class for animations
Qt3DAnimation::QAnimationGroup | A class grouping animations together
Qt3DAnimation::QBlendedClipAnimator | Component providing animation playback capabilities of a tree of blend nodes
Qt3DAnimation::QCallbackMapping | Allows to map the channels within the clip onto an invocation of a callback object
Qt3DAnimation::QChannel | Defines a channel for a QAnimationClipData. The animation system interpolates each channel component independently except in the case the QChannel is called "Rotation" (case sensitive), it has four QChannelComponents and the same number of keyframes for each QChannelComponent. In that case the interpolation will be performed using SLERP
Qt3DAnimation::QChannelMapper | Allows to map the channels within the clip onto properties of objects in the application
Qt3DAnimation::QChannelMapping | Allows to map the channels within the clip onto properties of objects in the application
Qt3DAnimation::QClipAnimator | Component providing simple animation playback capabilities
Qt3DAnimation::QClipBlendValue | Class used for including a clip in a blend tree
Qt3DAnimation::QKeyFrame | A base class for handling keyframes
Qt3DAnimation::QKeyframeAnimation | A class implementing simple keyframe animation to a QTransform
Qt3DAnimation::QLerpClipBlend | Performs a linear interpolation of two animation clips based on a normalized factor
Qt3DAnimation::QMorphTarget | A class providing morph targets to blend-shape animation
Qt3DAnimation::QMorphingAnimation | A class implementing blend-shape morphing animation
Qt3DAnimation::QVertexBlendAnimation | A class implementing vertex-blend morphing animation

### Qt 3D Scene2D Module

Qt3DRender::Quick::QScene2D | This class enables rendering qml into a texture, which then can be used as a part of 3D scene