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

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