Qt 3D C++ Classes

Qt3DCore::QAbstractAspect: QAbstractAspect is the base class for aspects that provide a vertical slice of behavior.

Qt3DCore::QAbstractSkeleton: A skeleton contains the joints for a skinned mesh.

Qt3DCore::QArmature: Used to calculate skinning transform matrices and set them on shaders.

Qt3DCore::QAspectEngine: Responsible for handling all the QAbstractAspect subclasses that have been registered with the scene.

Qt3DCore::QAspectJob: The base class for jobs executed in an aspect.

Qt3DCore::QBackendNode: The base class for all Qt3D backend nodes.

Qt3DCore::QBackendNodeMapper: Creates and maps backend nodes to their respective frontend nodes.

Qt3DCore::QComponent: The base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component.

Qt3DCore::QComponentAddedChange: The QComponentAddedChange class is used to notify when a component is added to an entity.

Qt3DCore::QComponentRemovedChange: The QComponentRemovedChange class is used to notify when a component is removed from an entity.

Qt3DCore::QDynamicPropertyUpdatedChange: The QDynamicPropertyUpdatedChange class is used to notify when a dynamic property value is updated.

Qt3DCore::QEntity: Qt3DCore::QEntity is a Qt3DCore::QNode subclass that can aggregate several Qt3DCore::QComponent instances that will specify its behavior.

Qt3DCore::QJoint: Used to transforms parts of skinned meshes.

Qt3DCore::QNode: QNode is the base class of all Qt3D node classes used to build a Qt3D scene.

Qt3DCore::QNodeCommand: The QNodeCommand class is the base class for all CommandRequested QSceneChange events.

Qt3DCore::QNodeCreatedChange: Used to notify when a node is created.

Qt3DCore::QNodeCreatedChangeBase: The QNodeCreatedChangeBase class is the base class for all NodeCreated QSceneChange events.

Qt3DCore::QNodeDestroyedChange: Used to notify when a node is destroyed.

Qt3DCore::QNodeId: Uniquely identifies a QNode.

Qt3DCore::QPropertyNodeAddedChange: Used to notify when a node is added to a property.

Qt3DCore::QPropertyNodeRemovedChange: The QPropertyNodeRemovedChange class is used to notify when a node is removed from a property.

Qt3DCore::QPropertyUpdatedChange: The QPropertyUpdatedChange class is used to notify when a property value is updated.

Qt3DCore::QPropertyUpdatedChangeBase: The QPropertyUpdatedChangeBase class is the base class for all PropertyUpdated QSceneChange events.

Qt3DCore::QPropertyValueAddedChange: Used to notify when a value is added to a property.

Qt3DCore::QPropertyValueAddedChangeBase: The QPropertyValueAddedChangeBase class is the base class for all PropertyValueAdded QSceneChange events.

Qt3DCore::QPropertyValueRemovedChange: Used to notify when a value is added to a property.

Qt3DCore::QPropertyValueRemovedChangeBase: The QPropertyValueRemovedChangeBase class is the base class for all PropertyValueRemoved QSceneChange events.

Qt3DCore::QSceneChange: The base class for changes that can be sent and received by Qt3D's change notification system.

Qt3DCore::QSkeleton: Holds the data for a skeleton to be used with skinned meshes.

Qt3DCore::QSkeletonLoader: Used to load a skeleton of joints from file.

Qt3DCore::QStaticPropertyUpdatedChangeBase: The QStaticPropertyUpdatedChangeBase class is the base class for all static PropertyUpdated QSceneChange events.

Qt3DCore::QStaticPropertyValueAddedChangeBase: The QStaticPropertyValueAddedChangeBase class is the base class for all static PropertyValueAdded QSceneChange events.

Qt3DCore::QStaticPropertyValueRemovedChangeBase: The QStaticPropertyValueRemovedChangeBase class is the base class for all static PropertyValueRemoved QSceneChange events.

Qt3DCore::QTransform: Used to perform transforms on meshes.

Qt3DCore::Quick::QQmlAspectEngine: The QQmlAspectEngine provides an environment for the QAspectEngine and a method for instantiating QML components.

Qt3DInput::QAbstractActionInput: QAbstractActionInput is the base class for the Action Input and all Aggregate Action Inputs.

Qt3DInput::QAbstractAxisInput: QAbstractActionInput is the base class for all Axis Input.

Qt3DInput::QAbstractPhysicalDevice: QAbstractPhysicalDevice is the base class used by Qt3d to interact with arbitrary input devices.

Qt3DInput::QAction: Links a set of QAbstractActionInput that trigger the same event.

Qt3DInput::QActionInput: QActionInput stores Device and Buttons used to trigger an input event.

Qt3DInput::QAnalogAxisInput: An axis input controlled by an analog input The axis value is controlled like a traditional analog input such as a joystick.

Qt3DInput::QAxis: QAxis stores QAbstractAxisInputs used to trigger an input event.

Qt3DInput::QAxisAccumulator: QAxisAccumulator processes velocity or acceleration data from a QAxis.

Qt3DInput::QAxisSetting: QAxisSetting stores settings for the specified list of Axis.

Qt3DInput::QButtonAxisInput: An axis input controlled by buttons The axis value is controlled by buttons rather than a traditional analog input such as a joystick.

Qt3DInput::QInputAspect: Responsible for creating physical devices and handling associated jobs.

Qt3DInput::QInputChord: QInputChord represents a set of QAbstractActionInput's that must be triggerd at once.

Qt3DInput::QInputSequence: QInputSequence represents a set of QAbstractActionInput's that must be triggerd one after the other.

Qt3DInput::QInputSettings: QInputSettings class holds the pointer to an input event source object.

Qt3DInput::QKeyEvent: QKeyEvent event type send by KeyBoardHandler.

Qt3DInput::QKeyboardDevice: QKeyboardDevice is in charge of dispatching keyboard events to attached QQKeyboardHandler objects.

Qt3DInput::QKeyboardHandler: Provides keyboard event notification.

Qt3DInput::QLogicalDevice: QLogicalDevice allows the user to define a set of actions that they wish to use within an application.

Qt3DInput::QMouseDevice: Delegates mouse events to the attached MouseHandler objects.

Qt3DInput::QMouseEvent: The Qt3DCore::QMouseEvent contains parameters that describe a mouse event.

Qt3DInput::QMouseHandler: Provides a means of being notified about mouse events when attached to a QMouseDevice instance.

Qt3DInput::QWheelEvent: The QWheelEvent class contains parameters that describe a mouse wheel event.

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

Qt3DLogic::QLogicAspect: Responsible for handling frame synchronization jobs.

Qt3DRender::QAbstractFunctor: QAbstractFunctor is an abstract base class for all functors.

Qt3DRender::QAbstractLight: Encapsulate a QAbstractLight object in a Qt 3D scene.

Qt3DRender::QAbstractRayCaster: An abstract base class for ray casting in 3d scenes.

Qt3DRender::QAbstractTexture: A base class to be used to provide textures.

Qt3DRender::QAbstractTextureImage: Encapsulates the necessary information to create an OpenGL texture image.

Qt3DRender::QAlphaCoverage: Enable alpha-to-coverage multisampling mode.

Qt3DRender::QAlphaTest: The QAlphaTest class specify alpha reference test.

Qt3DRender::QAttribute: Defines an attribute and how data should be read from a QBuffer.

Qt3DRender::QBlendEquation: The QBlendEquation class specifies the equation used for both the RGB blend equation and the Alpha blend equation.

Qt3DRender::QBlendEquationArguments: 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).

Qt3DRender::QBlitFramebuffer: FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another.

Qt3DRender::QBuffer: Provides a data store for raw data to later be used as vertices or uniforms.

Qt3DRender::QBufferCapture: Exchanges buffer data between GPU and CPU.

Qt3DRender::QBufferDataGenerator: Provides a mechanism to generate buffer data from a job.

Qt3DRender::QCamera: The QCamera class defines a view point through which the scene will be rendered.

Qt3DRender::QCameraLens: Qt3DRender::QCameraLens specifies the projection matrix that will be used to define a Camera for a 3D scene.

Qt3DRender::QCameraSelector: Class to allow for selection of camera to be used.

Qt3DRender::QClearBuffers: Class to clear buffers.

Qt3DRender::QClipPlane: Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance.

Qt3DRender::QColorMask: Allows specifying which color components should be written to the currently bound frame buffer.

Qt3DRender::QComputeCommand: QComponent to issue work for the compute shader on GPU.

Qt3DRender::QCullFace: The QCullFace class specifies whether front or back face culling is enabled.

Qt3DRender::QDepthTest: The QDepthTest class tests the fragment shader's depth value against the depth of a sample being written to.

Qt3DRender::QDirectionalLight: Encapsulate a Directional Light object in a Qt 3D scene.

Qt3DRender::QDispatchCompute: FrameGraph node to issue work for the compute shader on GPU.

Qt3DRender::QDithering: Enable dithering.

Qt3DRender::QEffect: The base class for effects in a Qt 3D scene.

Qt3DRender::QEnvironmentLight: Encapsulate an environment light object in a Qt 3D scene.

Qt3DRender::QFilterKey: The QFilterKey class provides storage for filter keys and their values.

Qt3DRender::QFrameGraphNode: Base class of all FrameGraph configuration nodes.

Qt3DRender::QFrameGraphNodeCreatedChangeBase: A base class for changes in the FrameGraphNode.

Qt3DRender::QFrontFace: The QFrontFace class defines front and back facing polygons.

Qt3DRender::QFrustumCulling: Enable frustum culling for the FrameGraph.

Qt3DRender::QGeometry: Encapsulates geometry.

Qt3DRender::QGeometryRenderer: Encapsulates geometry rendering.

Qt3DRender::QGraphicsApiFilter: The QGraphicsApiFilter class identifies the API required for the attached QTechnique.

Qt3DRender::QLayer: The QLayer class provides a way of filtering which entities will be rendered.

Qt3DRender::QLayerFilter: Controls layers drawn in a frame graph branch.

Qt3DRender::QLevelOfDetail: The QLevelOfDetail class provides a way of controlling the complexity of rendered entities based on their size on the screen.

Qt3DRender::QLevelOfDetailBoundingSphere: The QLevelOfDetailBoundingSphere class provides a simple spherical volume, defined by its center and radius.

Qt3DRender::QLevelOfDetailSwitch: Provides a way of enabling child entities based on distance or screen size.

Qt3DRender::QLineWidth: Specifies the width of rasterized lines.

Qt3DRender::QMaterial: Provides an abstract class that should be the base of all material component classes in a scene.

Qt3DRender::QMemoryBarrier: Class to emplace a memory barrier.

Qt3DRender::QMesh: A custom mesh loader.

Qt3DRender::QMultiSampleAntiAliasing: Enable multisample antialiasing.

Qt3DRender::QNoDepthMask: Disable depth write.

Qt3DRender::QNoDraw: When a Qt3DRender::QNoDraw node is present in a FrameGraph branch, this prevents the renderer from rendering any primitive.

Qt3DRender::QObjectPicker: The QObjectPicker class instantiates a component that can be used to interact with a QEntity by a process known as picking.

Qt3DRender::QPaintedTextureImage: A QAbstractTextureImage that can be written through a QPainter.

Qt3DRender::QParameter: Provides storage for a name and value pair. This maps to a shader uniform.

Qt3DRender::QPickEvent: The QPickEvent class holds information when an object is picked.

Qt3DRender::QPickLineEvent: The QPickLineEvent class holds information when a segment of a line is picked.

Qt3DRender::QPickPointEvent: The QPickPointEvent class holds information when a segment of a point cloud is picked.

Qt3DRender::QPickTriangleEvent: The QPickTriangleEvent class holds information when a triangle is picked.

Qt3DRender::QPickingSettings: The QPickingSettings class specifies how entity picking is handled.

Qt3DRender::QPointLight: Encapsulate a Point Light object in a Qt 3D scene.

Qt3DRender::QPointSize: Specifies the size of rasterized points. May either be set statically or by shader programs.

Qt3DRender::QPolygonOffset: The QPolygonOffset class sets the scale and steps to calculate depth values for polygon offsets.

Qt3DRender::QProximityFilter: Select entities which are within a distance threshold of a target entity.

Qt3DRender::QRayCaster: Qt3DRender::QRayCaster is used to perform ray casting tests in 3d world coordinates.

Qt3DRender::QRayCasterHit: Details of a hit when casting a ray through a model.

Qt3DRender::QRenderAspect: The QRenderAspect class.

Qt3DRender::QRenderCapture: Frame graph node for render capture.

Qt3DRender::QRenderCaptureReply: Receives the result of render capture request.

Qt3DRender::QRenderPass: Encapsulates a Render Pass.

Qt3DRender::QRenderPassFilter: Provides storage for vectors of Filter Keys and Parameters.

Qt3DRender::QRenderSettings: The QRenderSettings class holds settings related to rendering process and host the active FrameGraph.

Qt3DRender::QRenderState: An abstract base class for all render states.

Qt3DRender::QRenderStateSet: The QRenderStateSet FrameGraph node offers a way of specifying a set of QRenderState objects to be applied during the execution of a framegraph branch.

Qt3DRender::QRenderSurfaceSelector: Provides a way of specifying the render surface.

Qt3DRender::QRenderTarget: The QRenderTarget class encapsulates a target (usually a frame buffer object) which the renderer can render into.

Qt3DRender::QRenderTargetOutput: The QRenderTargetOutput class allows the specification of an attachment of a render target (whether it is a color texture, a depth texture, etc... ).

Qt3DRender::QRenderTargetSelector: Provides a way of specifying a render target.

Qt3DRender::QSceneLoader: Provides the facility to load an existing Scene.

Qt3DRender::QScissorTest: The QScissorTest class discards fragments that fall outside of a certain rectangular portion of the screen.

Qt3DRender::QScreenRayCaster: Performe ray casting test based on screen coordinates.

Qt3DRender::QSeamlessCubemap: Enables seamless cubemap texture filtering.

Qt3DRender::QShaderData: Provides a way of specifying values of a Uniform Block or a shader structure.

Qt3DRender::QShaderProgram: Encapsulates a Shader Program.

Qt3DRender::QShaderProgramBuilder: Generates a Shader Program content from loaded graphs.

Qt3DRender::QSortPolicy: Provides storage for the sort types to be used.

Qt3DRender::QSpotLight: Encapsulate a Spot Light object in a Qt 3D scene.

Qt3DRender::QStencilMask: The QStencilMask class controls the front and back writing of individual bits in the stencil planes.

Qt3DRender::QStencilOperation: The QStencilOperation class specifies stencil operation.

Qt3DRender::QStencilOperationArguments: The QStencilOperationArguments class sets the actions to be taken when stencil and depth tests fail.

Qt3DRender::QStencilTest: The QStencilTest class specifies arguments for the stecil test.

Qt3DRender::QStencilTestArguments: The QStencilTestArguments class specifies arguments for stencil test.

Qt3DRender::QTechnique: Encapsulates a Technique.

Qt3DRender::QTechniqueFilter: A QFrameGraphNode used to select QTechniques to use.

Qt3DRender::QTexture1D: A QAbstractTexture with a Target1D target format.

Qt3DRender::QTexture1DArray: A QAbstractTexture with a Target1DArray target format.

Qt3DRender::QTexture2D: A QAbstractTexture with a Target2D target format.

Qt3DRender::QTexture2DArray: A QAbstractTexture with a Target2DArray target format.

Qt3DRender::QTexture2DMultisample: A QAbstractTexture with a Target2DMultisample target format.

Qt3DRender::QTexture2DMultisampleArray: A QAbstractTexture with a Target2DMultisampleArray target format.

Qt3DRender::QTexture3D: A QAbstractTexture with a Target3D target format.

Qt3DRender::QTextureBuffer: A QAbstractTexture with a TargetBuffer target format.

Qt3DRender::QTextureCubeMap: A QAbstractTexture with a TargetCubeMap target format.

Qt3DRender::QTextureCubeMapArray: A QAbstractTexture with a TargetCubeMapArray target format.

Qt3DRender::QTextureData: The QTextureData class stores texture information such as the target, height, width, depth, layers, wrap, and if mipmaps are enabled.

Qt3DRender::QTextureImage: Encapsulates the necessary information to create an OpenGL texture image from an image source.

Qt3DRender::QTextureImageData: QTextureImageData stores data representing a texture.

Qt3DRender::QTextureImageDataGenerator: Provides texture image data for QAbstractTextureImage.

Qt3DRender::QTextureLoader: Handles the texture loading and setting the texture's properties.

Qt3DRender::QTextureRectangle: A QAbstractTexture with a TargetRectangle target format.

Qt3DRender::QTextureWrapMode: Defines the wrap mode a Qt3DRender::QAbstractTexture should apply to a texture.

Qt3DRender::QViewport: A viewport on the Qt3D Scene.

Qt3DExtras::QAbstractCameraController: The QAbstractCameraController class provides basic functionality for camera controllers.

Qt3DExtras::QConeGeometry: The QConeGeometry class allows creation of a cone in 3D space. * * * * * The QConeGeometry class is most commonly used internally by the QConeMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses. The class * allows for creation of both a cone and a truncated cone.

Qt3DExtras::QConeMesh: A conical mesh.

Qt3DExtras::QCuboidGeometry: The QCuboidGeometry class allows creation of a cuboid in 3D space. * * * * * The QCuboidGeometry class is most commonly used internally by the QCuboidMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses.

Qt3DExtras::QCuboidMesh: A cuboid mesh.

Qt3DExtras::QCylinderGeometry: The QCylinderGeometry class allows creation of a cylinder in 3D space. * * * * * The QCylinderGeometry class is most commonly used internally by the QCylinderMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses.

Qt3DExtras::QCylinderMesh: A cylindrical mesh.

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

Qt3DExtras::QExtrudedTextGeometry: The QExtrudedTextGeometry class allows creation of a 3D extruded text in 3D space.

Qt3DExtras::QExtrudedTextMesh: A 3D extruded Text mesh.

Qt3DExtras::QFirstPersonCameraController: The QFirstPersonCameraController class allows controlling the scene camera from the first person perspective.

Qt3DExtras::QForwardRenderer: The QForwardRenderer provides a default FrameGraph implementation of a forward renderer.

Qt3DExtras::QGoochMaterial: The QGoochMaterial provides a material that implements the Gooch shading model, popular in CAD and CAM applications.

Qt3DExtras::QMetalRoughMaterial: The QMetalRoughMaterial provides a default implementation of PBR lighting.

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

Qt3DExtras::QOrbitCameraController: The QOrbitCameraController class allows controlling the scene camera along orbital path.

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

Qt3DExtras::QPlaneGeometry: The QPlaneGeometry class allows creation of a plane in 3D space. * * * * The QPlaneGeometry class is most commonly used internally by the QPlaneMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses.

Qt3DExtras::QPlaneMesh: A square planar mesh.

Qt3DExtras::QSkyboxEntity: Qt3DExtras::QSkyboxEntity is a convenience Qt3DCore::QEntity subclass that can be used to insert a skybox in a 3D scene.

Qt3DExtras::QSphereGeometry: The QSphereGeometry class allows creation of a sphere in 3D space. * * * * * The QSphereGeometry class is most commonly used internally by the QSphereMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses.

Qt3DExtras::QSphereMesh: A spherical mesh.

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

Qt3DExtras::QTextureMaterial: The QTextureMaterial provides a default implementation of a simple unlit texture material.

Qt3DExtras::QTorusGeometry: The QTorusGeometry class allows creation of a torus in 3D space. * * * * * The QTorusGeometry class is most commonly used internally by the QTorusMesh * but can also be used in custom Qt3DRender::QGeometryRenderer subclasses.

Qt3DExtras::QTorusMesh: A toroidal mesh.

Qt3DAnimation::QAbstractAnimation: An abstract base class for Qt3D animations.

Qt3DAnimation::QAbstractAnimationClip: QAbstractAnimationClip is the base class for types providing key frame animation data.

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

Qt3DAnimation::QAbstractClipBlendNode: QAbstractClipBlendNode is the base class for types used to construct animation blend trees.

Qt3DAnimation::QAdditiveClipBlend: Performs an additive blend of two animation clips based on an additive factor.

Qt3DAnimation::QAnimationAspect: Provides key-frame animation capabilities to Qt 3D.

Qt3DAnimation::QAnimationClipLoader: Enables loading key frame animation data from a file.

Qt3DAnimation::QAnimationController: A controller class for animations.

Qt3DAnimation::QAnimationGroup: A class grouping animations together.

Qt3DAnimation::QBlendedClipAnimator: QBlendedClipAnimator is a component providing animation playback capabilities of a tree of blend nodes.

Qt3DAnimation::QClipAnimator: QClipAnimator is a component providing simple animation playback capabilities.

Qt3DAnimation::QClipBlendNodeCreatedChangeBase: Base class for changes in QClipBlendNode.

Qt3DAnimation::QKeyFrame: A base class for handling keyframes.

Qt3DAnimation::QKeyframeAnimation: A class implementing simple keyframe animation to a QTransform.

Qt3DAnimation::QLerpClipBlend: Performs a linear interpolation of two animation clips based on a normalized factor.

Qt3DAnimation::QMorphTarget: A class providing morph targets to blend-shape animation.

Qt3DAnimation::QMorphingAnimation: A class implementing blend-shape morphing animation.

Qt3DAnimation::QVertexBlendAnimation: A class implementing vertex-blend morphing animation.

Qt3DRender::Quick::QScene2D: This class enables rendering qml into a texture, which then can be used as a part of 3D scene.