Qt 3D QML Types

The Qt 3D core QML types are imported with

 import Qt3D.Core 2.15

Other modules import functionality for collision detection, rendering, input, and animation. The complete list of Qt 3D import statements:

 import Qt3D.Core 2.15
 import Qt3D.Render 2.15
 import Qt3D.Input 2.15
 import Qt3D.Logic 2.15
 import Qt3D.Extras 2.15
 import Qt3D.Animation 2.15
 import QtQuick.Scene2D 2.15
 import QtQuick.Scene3D 2.15

QML Types

Qt 3D Core Module

AbstractSkeleton	A skeleton contains the joints for a skinned mesh
Armature	Used to calculate skinning transform matrices and set them on shaders
Component3D	Provides the base type for creating Qt 3D components
Entity	Node subclass that can aggregate several Component3D instances that will specify its behavior
EntityLoader	Provides a way to dynamically load an Entity subtree
Joint	Used to transforms parts of skinned meshes
Node	A base QML type that other types inherit. It cannot be directly created
NodeInstantiator	Dynamically creates nodes
QuaternionAnimation	A PropertyAnimation for quaternions
Skeleton	Holds the data for a skeleton to be used with skinned meshes
SkeletonLoader	Used to load a skeleton of joints from file
Transform	Used to perform transforms on meshes

Qt 3D Input Module

AbstractActionInput	QML frontend for the abstract Qt3DInput::QAbstractActionInput C++ class
AbstractAxisInput	QML frontend for abstract QAbstractAxisInput C++ class
AbstractPhysicalDevice	QML frontend for the abstract Qt3DInput::QAbstractPhysicalDevice C++ class
Action	QML frontend for the Qt3DInput::QAction C++ class
ActionInput	QML frontend for the Qt3DInput::QActionInput C++ class
AnalogAxisInput	QML frontend for QAnalogAxisInput C++ class
Axis	QML frontend for the Qt3DInput::QAxis C++ class
AxisAccumulator	QML frontend for the Qt3DInput::QAxisAccumulator C++ class
AxisSetting	QML frontend for the Qt3DInput::QAxisSetting C++ class
ButtonAxisInput	QML frontend for QButtonAxisInput C++ class. The axis value is controlled by buttons rather than a traditional analog input such as a joystick
InputChord	QML frontend for the Qt3DInput::QInputChord C++ class
InputSequence	QML frontend for the Qt3DInput::QInputSequence C++ class
InputSettings	Holds the pointer to an input event source object
KeyEvent	QML frontend for QKeyEvent C++ class
KeyboardDevice	QML frontend for QKeyboardDevice C++ class
KeyboardHandler	QML frontend for QKeyboardHandler C++ class
LogicalDevice	QML frontend for the Qt3DInput::QLogicalDevice C++ class
MouseDevice	Delegates mouse events to the attached MouseHandler objects
MouseEvent	Provides parameters that describe a mouse event
MouseHandler	Provides mouse event notification
WheelEvent	Contains parameters that describe a mouse wheel event

Qt 3D Logic Module

FrameAction

Provides a way to have a synchronous function executed each frame

Qt 3D Render Module

AbstractRayCaster	An abstract base class for ray casting in 3d scenes
AbstractTexture	A base class to be used to provide textures
AbstractTextureImage	Encapsulates the necessary information to create an OpenGL texture image
AlphaCoverage	Enable alpha-to-coverage multisampling mode
AlphaTest	Specify alpha reference test
Attribute	Defines an attribute and how data should be read from a Buffer
BlendEquation	Specifies the equation used for both the RGB blend equation and the Alpha blend equation
BlendEquationArguments	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)
BlitFramebuffer	FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another
Buffer	Provides a data store for raw data to later be used as vertices or uniforms
BufferCapture	Exchanges buffer data between GPU and CPU
Camera	Defines a view point through which the scene will be rendered
CameraLens	Provides the projection matrix that is used to define a Camera for 3D scene
CameraSelector	Class to allow for selection of camera to be used
ClearBuffers	Class to clear buffers
ClipPlane	Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance
ColorMask	Allows specifying which color components should be written to the currently bound frame buffer
ComputeCommand	Component to issue work for the compute shader on GPU
CullFace	Type specifies whether front or back face culling is enabled
DepthRange	Enables remapping depth values written into the depth buffer
DepthTest	Type tests the fragment shader's depth value against the depth of a sample being written to
DirectionalLight	Encapsulate a Directional Light object in a Qt 3D scene
DispatchCompute	FrameGraph node to issue work for the compute shader on GPU
Dithering	Enable dithering
Effect	Base class for effects in a Qt 3D scene
EnvironmentLight	Encapsulate an environment light object in a Qt 3D scene
FilterKey	Stores filter keys and their values
FrameGraphNode	Base class of all FrameGraph configuration nodes
FrontFace	Type defines front and back facing polygons
FrustumCulling	Enable frustum culling for the FrameGraph
Geometry	Encapsulates geometry
GeometryRenderer	Encapsulates geometry rendering
GraphicsApiFilter	For OpenGL identifies the API required for the attached technique
Layer	Way of filtering which entities will be rendered
LayerFilter	Controls layers drawn in a frame graph branch
LevelOfDetail	Way of controlling the complexity of rendered entities based on their size on the screen
LevelOfDetailBoundingSphere	QML type provides a simple spherical volume, defined by its center and radius
LevelOfDetailLoader	An entity loader that changes depending on distance to camera or screen size
LevelOfDetailSwitch	Provides a way of enabling child entities based on distance or screen size
Light	Encapsulate a QAbstractLight object in a Qt 3D scene
LineWidth	Specifies the width of rasterized lines
Material	Non-creatable abstract base for materials
MemoryBarrier	Class to place a memory barrier
Mesh	A custom mesh loader
MultiSampleAntiAliasing	Enable multisample antialiasing
NoDepthMask	Disable depth write
NoDraw	When a NoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive
NoPicking	When a NoPicking node is present in a FrameGraph branch, this prevents the render aspect from performing picking selection for the given branch
ObjectPicker	Instantiates a component that can be used to interact with an Entity by a process known as picking
Parameter	Provides storage for a name and value pair. This maps to a shader uniform
PickEvent	Holds information when an object is picked. This is received as a parameter in most of the QObjectPicker component signals when picking succeeds
PickLineEvent	Holds information when a segment of a line is picked
PickPointEvent	Holds information when a segment of a point cloud is picked
PickTriangleEvent	Holds information when a triangle is picked
PickingSettings	Specifies how entity picking is handled
PointLight	Encapsulate a Point Light object in a Qt 3D scene
PointSize	Specifies the size of rasterized points. May either be set statically or by shader programs
PolygonOffset	Type sets the scale and steps to calculate depth values for polygon offsets
ProximityFilter	Select entities which are within a distance threshold of a target entity
RasterMode	Render state allows to control the type of rasterization to be performed
RayCaster	Used to perform ray casting tests in 3d world coordinates
RenderCapabilities	QRenderCapabilities class holds settings related to available rendering engines
RenderCapture	Capture rendering
RenderCaptureReply	Receives render capture result
RenderPass	Encapsulates a Render Pass
RenderPassFilter	Provides storage for vectors of Filter Keys and Parameters
RenderSettings	Type holds settings related to rendering process and host the active FrameGraph
RenderState	An abstract base type for all render states
RenderStateSet	FrameGraph node offers a way of specifying a set of RenderState objects to be applied during the execution of a framegraph branch
RenderSurfaceSelector	Provides a way of specifying the render surface
RenderTarget	Encapsulates a target (usually a frame buffer object) which the renderer can render into
RenderTargetOutput	Type allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... )
RenderTargetSelector	Provides a way of specifying a render target
SceneLoader	Provides the facility to load an existing Scene
ScissorTest	Type discards fragments that fall outside of a certain rectangular portion of the screen
ScreenRayCaster	Performe ray casting test based on screen coordinates
SeamlessCubemap	Enables seamless cubemap texture filtering
ShaderImage	Provides Image access to shader programs
ShaderProgram	Encapsulates a Shader Program
ShaderProgramBuilder	Generates a Shader Program content from loaded graphs
SharedGLTexture	Allows to use a textureId from a separate OpenGL context in a Qt 3D scene
SortPolicy	Provides storage for the sort types to be used
SpotLight	Encapsulate a Spot Light object in a Qt 3D scene
StencilMask	Type controls the front and back writing of individual bits in the stencil planes
StencilOperation	Type specifies stencil operation
StencilOperationArguments	Type sets the actions to be taken when stencil and depth tests fail
StencilTest	Type specifies arguments for the stecil test
StencilTestArguments	Type specifies arguments for stencil test
SubtreeEnabler	Enables or disables entire subtrees of frame graph nodes
Technique	Encapsulates a Technique
TechniqueFilter	A FrameGraphNode used to select used Techniques
Texture1D	An AbstractTexture with a Target1D target format
Texture1DArray	An AbstractTexture with a Target1DArray target format
Texture2D	An AbstractTexture with a Target2D target format
Texture2DArray	An AbstractTexture with a Target2DArray target format
Texture2DMultisample	An AbstractTexture with a Target2DMultisample target format
Texture2DMultisampleArray	An AbstractTexture with a Target2DMultisampleArray target format
Texture3D	An AbstractTexture with a Target3D target format
TextureBuffer	An AbstractTexture with a TargetBuffer target format
TextureCubeMap	An AbstractTexture with a TargetCubeMap target format
TextureCubeMapArray	An AbstractTexture with a TargetCubeMapArray target format
TextureImage	Encapsulates the necessary information to create an OpenGL texture image from an image source
TextureLoader	Handles the texture loading and setting the texture's properties
TextureRectangle	An AbstractTexture with a TargetRectangle target format
Viewport	A viewport on the Qt3D Scene

Qt 3D Extras Module

ConeGeometry	Allows creation of a cone in 3D space
ConeMesh	A conical mesh
CuboidGeometry	Allows creation of a cuboid in 3D space
CuboidMesh	A cuboid mesh
CylinderGeometry	Allows creation of a cylinder in 3D space
CylinderMesh	A cylindrical mesh
DiffuseSpecularMaterial	Default implementation of the phong lighting effect
ExtrudedTextGeometry	Allows creation of a 3D text in 3D space
ExtrudedTextMesh	A 3D extruded Text mesh
FirstPersonCameraController	Allows controlling the scene camera from the first person perspective
ForwardRenderer	Default FrameGraph implementation of a forward renderer
GoochMaterial	Material that implements the Gooch shading model, popular in CAD and CAM applications
MetalRoughMaterial	This material uses an effect with a single render pass approach and performs per fragment lighting. Techniques are provided for OpenGL 3 and OpenGL ES 3
OrbitCameraController	Allows controlling the scene camera along orbital path
PerVertexColorMaterial	Default implementation for rendering the color properties set for each vertex
PlaneGeometry	Allows creation of a plane in 3D space
PlaneMesh	A square planar mesh
SkyboxEntity	Convenience Entity subclass that can be used to insert a skybox in a 3D scene
SphereGeometry	Allows creation of a sphere in 3D space
SphereMesh	A spherical mesh
Text2DEntity	Allows creation of a 2D text in 3D space
TorusGeometry	Allows creation of a torus in 3D space
TorusMesh	A toroidal mesh

Qt 3D Animation Module

AbstractAnimation	An abstract base type for Qt3D animations
AbstractClipAnimator	The base class for types providing animation playback capabilities
AbstractClipBlendNode	The base class for types used to construct animation blend trees
AdditiveClipBlend	Performs an additive blend of two animation clips based on an additive factor
AnimationController	A controller type for animations
AnimationGroup	A type grouping animations together
BlendedClipAnimator	Component providing animation playback capabilities of a tree of blend nodes
ClipAnimator	Component providing simple animation playback capabilities
ClipBlendValue	Type used for including a clip in a blend tree
KeyframeAnimation	A type implementing simple keyframe animation to a Transform
LerpClipBlend	Performs a linear interpolation of two animation clips based on a normalized factor
MorphTarget	A type providing morph targets to blend-shape animation
MorphingAnimation	A type implementing blend-shape morphing animation
VertexBlendAnimation	A type implementing vertex-blend morphing animation

Qt 3D Scene2D Module

Scene2D

This type enables rendering qml into a texture, which then can be used as a part of 3D scene

Qt 3D Scene3D Module

Scene3D	Type is used to integrate a Qt3D scene into a QtQuick 2 scene
Scene3DView	Type is used to integrate a Qt 3D sub scene into a QtQuick 2 scene using Scene3D. Whereas you should only use a single Scene3D instance per application, you can have multiple Scene3DView instances

Contents