Learn what Felgo offers to help your business succeed. Start your free evaluation today! Felgo for Your Business

Qt 3D Render QML Types

This module was introduced in Qt 5.7.

To import and use the module's QML types, use the following statement:

import Qt3D.Render 2.4

Selecting a Rendering Backend

The Render aspect comes with two rendering backends.

  • OpenGL backend (ES 2, ES 3.2, GL 2, GL 3, GL 3.2, GL 4.3)
  • RHI backend (ES 2, GL, DirectX, Vulkan, Metal)

If you are targeting OpenGL exclusively and are using specific OpenGL features, you might be better off using the OpenGL backend. This is the OpenGL backend that Qt 3D exclusively used in the Qt 5 series.

For cases where you are not using specific OpenGL features and want to target different platforms that might have deprecated OpenGL, using the RHI backend is a better alternative.

To select your rendering backend, the environment variable QT3D_RENDERER is to be set to either "opengl" or "rhi". Defaults to the OpenGL backend.

When using the RHI backend, you can further force the internal RHI backend by setting the QSG_RHI_BACKEND to one of the following values:

  • opengl -> RHI OpenGL backend
  • gl -> RHI OpenGL backend
  • gles2 -> RHI OpenGL backend
  • metal -> RHI Metal backend
  • vulkan -> RHI Vulkan backend
  • d3d11 -> RHI DirectX 11 backend

If not specified, RHI will default to what it deduces to be the best backend for the platform.

Alternatively, if using a QQuickWindow, QQuickWindow::setGraphicsApi() can be used to specify the RHI internal rendering backend.

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

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

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

Qt_Technology_Partner_RGB_475 Qt_Service_Partner_RGB_475_padded