- Qt 6.8
- Qt 3D
- Qt 3D QML Types
- Qt 6.8.2 Reference Documentation

# Qt 3D QML Types

The Qt 3D core QML types are imported with

     import Qt3D.Core 2.8

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

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

## 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
Attribute | Defines an attribute and how data should be read from a Buffer
BoundingVolume | Can be used to override an entity's bounding volume
Buffer | Provides a data store for raw data to later be used as vertices or uniforms
Component3D | Provides the base type for creating Qt 3D components
CoreSettings | Holds settings related to core data handling process
Entity | Node subclass that can aggregate several Component3D instances that will specify its behavior
EntityLoader | Provides a way to dynamically load an Entity subtree
Geometry | Encapsulates geometry
GeometryView | Encapsulates geometry details
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
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
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
DebugOverlay | Enables a visual overlay with scene details
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
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
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
PickingProxy | Can be used to provide an alternate GeometryView used only for picking
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
levelOfDetailBoundingSphere | QML type provides a simple spherical volume, defined by its center and radius

### Qt 3D Extras Module

ConeGeometry | Allows creation of a cone in 3D space
ConeGeometryView | A conical mesh
ConeMesh | A conical mesh
CuboidGeometry | Allows creation of a cuboid in 3D space
CuboidGeometryView | A cuboid mesh
CuboidMesh | A cuboid mesh
CylinderGeometry | Allows creation of a cylinder in 3D space
CylinderGeometryView | A cylindrical mesh
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
PlaneGeometryView | A square planar mesh
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
SphereGeometryView | A spherical mesh
SphereMesh | A spherical mesh
Text2DEntity | Allows creation of a 2D text in 3D space
TorusGeometry | Allows creation of a torus in 3D space
TorusGeometryView | A toroidal mesh
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