IdentifiantMot de passe
Mot de passe oublié ?Je m'inscris ! (gratuit)

Qt 3D QML Types

QML Types for the Qt 3D module.

This documentation was introduced in Qt 5.7.

Article lu   fois.

L'auteur

L'article

Publié le - Mis à jour le 26 janvier 2024 

Liens sociaux

Viadeo Twitter Facebook Share on Google+   

Qt 3D QML Types▲

The Qt 3D core QML types are imported with

 
Sélectionnez
import Qt3D.Core 2.4

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

 
Sélectionnez
import Qt3D.Core 2.4
import Qt3D.Render 2.4
import Qt3D.Input 2.4
import Qt3D.Logic 2.4
import Qt3D.Extras 2.4
import Qt3D.Animation 2.4
import QtQuick.Scene2D 2.4
import QtQuick.Scene3D 2.4

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: The CoreSettings class holds settings related to core data handling process.

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

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

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

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

  • DebugOverlay: Enables a visual overlay with scene details.

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

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

  • PickingProxy: Can be used to provide an alternate GeometryView used only for picking.

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

Qt 3D Extras Module▲

Qt 3D Animation Module▲

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

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: The Scene3D type is used to integrate a Qt3D scene into a QtQuick 2 scene.

Vous avez aimé ce tutoriel ? Alors partagez-le en cliquant sur les boutons suivants : Viadeo Twitter Facebook Share on Google+