Qt 3D QML Types

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: Entity is a 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.

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: 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.

FrameAction: Provides a way to have a synchronous function executed each frame.

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: The AlphaTest class specify alpha reference test.

Attribute: Defines an attribute and how data should be read from a Buffer.

BlendEquation: The BlendEquation class 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: The CullFace type specifies whether front or back face culling is enabled.

DepthRange: Enables remapping depth values written into the depth buffer.

DepthTest: The 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: The 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: The 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: Layer provides a way of filtering which entities will be rendered.

LayerFilter: Controls layers drawn in a frame graph branch.

LevelOfDetail: LevelOfDetail provides a way of controlling the complexity of rendered entities based on their size on the screen.

LevelOfDetailBoundingSphere: The 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: The ObjectPicker class 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: 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: PickLineEvent holds information when a segment of a line is picked.

PickPointEvent: PickPointEvent holds information when a segment of a point cloud is picked.

PickTriangleEvent: PickTriangleEvent holds information when a triangle is picked.

PickingSettings: The PickingSettings class 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: The 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: The 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: The 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: The RenderSettings type holds settings related to rendering process and host the active FrameGraph.

RenderState: An abstract base type for all render states.

RenderStateSet: The 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: The RenderTarget class encapsulates a target (usually a frame buffer object) which the renderer can render into.

RenderTargetOutput: The 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: The 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: The StencilMask type controls the front and back writing of individual bits in the stencil planes.

StencilOperation: The StencilOperation type specifies stencil operation.

StencilOperationArguments: The StencilOperationArguments type sets the actions to be taken when stencil and depth tests fail.

StencilTest: The StencilTest type specifies arguments for the stecil test.

StencilTestArguments: The 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.

ConeGeometry: ConeGeometry allows creation of a cone in 3D space.

ConeMesh: A conical mesh.

CuboidGeometry: CuboidGeometry allows creation of a cuboid in 3D space.

CuboidMesh: A cuboid mesh.

CylinderGeometry: CylinderGeometry allows creation of a cylinder in 3D space.

CylinderMesh: A cylindrical mesh.

DiffuseSpecularMaterial: The DiffuseSpecularMaterial class provides a default implementation of the phong lighting effect.

ExtrudedTextGeometry: ExtrudedTextGeometry allows creation of a 3D text in 3D space.

ExtrudedTextMesh: A 3D extruded Text mesh.

FirstPersonCameraController: The FirstPersonCameraController allows controlling the scene camera from the first person perspective.

ForwardRenderer: The ForwardRenderer provides a default FrameGraph implementation of a forward renderer.

GoochMaterial: The GoochMaterial provides a 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: The OrbitCameraController class allows controlling the scene camera along orbital path.

PerVertexColorMaterial: The PerVertexColorMaterial class provides a default implementation for rendering the color properties set for each vertex.

PlaneGeometry: PlaneGeometry allows creation of a plane in 3D space.

PlaneMesh: A square planar mesh.

SkyboxEntity: SkyboxEntity is a convenience Entity subclass that can be used to insert a skybox in a 3D scene.

SphereGeometry: SphereGeometry allows creation of a sphere in 3D space.

SphereMesh: A spherical mesh.

Text2DEntity: Text2DEntity allows creation of a 2D text in 3D space.

TorusGeometry: TorusGeometry allows creation of a torus in 3D space.

TorusMesh: A toroidal mesh.

AbstractAnimation: An abstract base type for Qt3D animations.

AbstractClipAnimator: AbstractClipAnimator is the base class for types providing animation playback capabilities.

AbstractClipBlendNode: AbstractClipBlendNode is 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: BlendedClipAnimator is a component providing animation playback capabilities of a tree of blend nodes.

ClipAnimator: ClipAnimator is a 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.

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

Scene3D: The Scene3D type is used to integrate a Qt3D scene into a QtQuick 2 scene.

Scene3DView: The 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.