Qt 3D C++ Classes

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

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

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::QAttribute: Defines an attribute and how data should be read from a QBuffer.

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

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

Qt3DCore::QBoundingVolume: can be used to override the bounding volume of an entity.

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

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

Qt3DCore::QCoreSettings: The QCoreSettings class holds settings related to core data handling process.

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

Qt3DCore::QGeometry: Encapsulates geometry.

Qt3DCore::QGeometryView: Encapsulates geometry details.

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::QNodeId: Uniquely identifies a QNode.

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::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::QAbstractPhysicalDeviceProxy: Qt3DInput::QAbstractPhysicalDeviceProxy acts as a proxy for an actual Qt3DInput::QQAbstractPhysicalDevice device.

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::QInputDeviceIntegration: Abstract base class used to define new input methods such as game controllers.

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::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::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::QBufferCapture: Exchanges buffer data between GPU and CPU.

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::QDebugOverlay: Enables a visual overlay with scene details.

Qt3DRender::QDepthRange: Enables remapping depth values written into the depth buffer.

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::QFrontFace: The QFrontFace class defines front and back facing polygons.

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

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::QNoPicking: When a Qt3DRender::QNoPicking node is present in a FrameGraph branch, this prevents the render aspect from performing picking selection for the given branch.

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::QPickingProxy: Can be used to provide an alternate QGeometryView used only for picking.

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::QRasterMode: The QRasterMode render state allows to control the type of rasterization to be performed.

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::QRenderCapabilities: The QRenderCapabilities class holds settings related to available rendering engines.

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::QSetFence: FrameGraphNode used to insert a fence in the graphics command stream.

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

Qt3DRender::QShaderImage: Provides Image access to shader programs.

Qt3DRender::QShaderProgram: Encapsulates a Shader Program.

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

Qt3DRender::QSharedGLTexture: Allows to use a textureId from a separate OpenGL context in a Qt 3D scene.

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::QSubtreeEnabler: Enables or disables entire subtrees of framegraph nodes.

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::QTextureDataUpdate: QTextureDataUpdate holds content and information required to perform partial updates of a texture content.

Qt3DRender::QTextureGenerator: Provides the image data for a texture.

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.

Qt3DRender::QWaitFence: FrameGraphNode used to wait for a fence in the graphics command stream to become signaled.

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

Qt3DExtras::QConeGeometry: The QConeGeometry class allows creation of a cone in 3D space.

Qt3DExtras::QConeGeometryView: A conical mesh.

Qt3DExtras::QConeMesh: A conical mesh.

Qt3DExtras::QCuboidGeometry: The QCuboidGeometry class allows creation of a cuboid in 3D space.

Qt3DExtras::QCuboidGeometryView: A cuboid mesh.

Qt3DExtras::QCuboidMesh: A cuboid mesh.

Qt3DExtras::QCylinderGeometry: The QCylinderGeometry class allows creation of a cylinder in 3D space.

Qt3DExtras::QCylinderGeometryView: A cylindrical mesh.

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.

Qt3DExtras::QPlaneGeometryView: A square planar mesh.

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.

Qt3DExtras::QSphereGeometryView: A spherical mesh.

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.

Qt3DExtras::QTorusGeometryView: A toroidal mesh.

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::QAnimationCallback: Represents an animation callback object.

Qt3DAnimation::QAnimationClip: Specifies key frame animation data.

Qt3DAnimation::QAnimationClipData: Class containing the animation data.

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::QCallbackMapping: Allows to map the channels within the clip onto an invocation of a callback object.

Qt3DAnimation::QChannel: Defines a channel for a QAnimationClipData. The animation system interpolates each channel component independently except in the case the QChannel is called "Rotation" (case sensitive), it has four QChannelComponents and the same number of keyframes for each QChannelComponent. In that case the interpolation will be performed using SLERP.

Qt3DAnimation::QChannelMapper: Allows to map the channels within the clip onto properties of objects in the application.

Qt3DAnimation::QChannelMapping: Allows to map the channels within the clip onto properties of objects in the application.

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

Qt3DAnimation::QClipBlendValue: Class used for including a clip in a blend tree.

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.