Methods for rendering 3D bar graphs

Basic wheel mouse based input handler

Simple base class for all the objects in a 3D scene

Description of the 3D scene being visualized

Visual style for graphs

Window and render loop for graphs

Base class for all data series

Base class used for specialized axis classes

The abstract base class of button widgets, providing functionality common to buttons

Interface to manage Qt's event queue

Interface for extension managers in Qt Designer

Default implementation for classes that create user interfaces at run-time

Used to display and edit data items from a model

Helps testing QAbstractItemModel subclasses

Abstract model that can be subclassed to create one-dimensional list models

The interface for cache implementations

The base of all implementations of OAuth 2 authentication methods

The base class of a family of classes that expose all functions for each OpenGL version and profile

Base class for proxy item models that can do sorting, filtering or other data processing tasks

Base class for all Qt Chart series

The base functionality common to all socket types

The base class of states of a QStateMachine

Abstract base class used to implement custom layouts for QTextDocuments

Enums and static functions related to accessibility

Implements support for objects with editable text

Defines an interface that exposes information about accessible objects

Abstract base class for plugins provinding accessibility information for user interface elements

Implements support for the IAccessibleTable2 Cell interface

Signifies a change in a table, list, or tree where cells are added or removed. If the change affected a number of rows, firstColumn and lastColumn will return -1. Likewise for columns, the row functions may return -1

Notifies of text being inserted

Notifies of text being deleted

Notifies about text changes. This is for accessibles that support editable text such as line edits. This event occurs for example when a portion of selected text gets replaced by pasting a new text or in override mode of editors

Implements support for objects that manipulate a value

Abstraction for user commands that can be added to different user interface components

Groups actions together

Abstract base class for groups of animations

Manages the GUI application's control flow and main settings

Presents data in area charts

Platform-independent atomic operations on int

Template class that provides platform-independent atomic operations on pointers

Abstract base class for implementations of additional COM interfaces

Static properties and signals for QAxObject

Interface between a QWidget and an ActiveX client

QObject that wraps a COM object

Wrapper around script code

Bridge between application objects and script code

QWidget that wraps an ActiveX control

Drawing area for QWindow

Adds categories to a chart's axes

The data proxy for a 3D bars graph

Presents a series of data as vertical bars grouped by category

Wrapper class around binding-enabled properties. It allows type-safe operations while abstracting the differences between the various property classes away

Monochrome (1-bit depth) pixmaps

Legend marker for a box plot series

Represents one item in a box-and-whiskers chart

QIODevice interface for a QByteArray

Array of bytes

Holds a sequence of bytes that can be quickly matched in a byte array

Template class that provides a cache

Monthly based calendar widget allowing the user to select a date

Abstract model mapper class for candlestick series

Represents a single candlestick item in a candlestick chart

Places named ranges on the axis

Holds the error condition found while parsing or validating a CBOR stream

Used by QCborValue to report a parsing error

Simple CBOR encoder operating on a one-way stream

16-bit Unicode character

Standalone widget that can display charts

Contains event parameters for child object events

Contains parameters that describe a close event

Holds information about a CoAP message that can be a request or a reply

Interface for managing CoAP security keys

Holds a CoAP request. This request can be sent with QCoapClient

Holds the data of a CoAP reply for a resource discovery request

Compares strings according to a localized collation algorithm

Colors based on RGB, HSV or CMYK values

Color space abstraction

Maps device independent QColors to device dependent pixel values

Combined button and popup list

Means for handling the command line options

Encapsulates the common Look and Feel of a GUI

Access to the details about a compressed help file

Used in combination with QBrush to specify a conical gradient brush

Contains parameters that describe a context menu event

Event loop for Qt applications without UI

Mouse cursor with an arbitrary shape

Adds a custom label to a graph

The base class of D-Bus adaptor classes

Used to marshall and demarshall D-Bus arguments

Access to the D-Bus bus daemon service

Represents an error received from the D-Bus bus or from remote applications found in the bus

Represents one message sent or received over the D-Bus bus

Refers to one pending asynchronous call

Contains the reply to an asynchronous method call

Peer-to-peer communication between processes on the same computer

Enables the programmer to identify the SIGNATURE type provided by the D-Bus typesystem

Enables the programmer to identify the variant type provided by the D-Bus typesystem

Serialization of binary data to a QIODevice

Date functions

Date and time functions

Widget for editing dates and times

Output stream for debugging information

Allows you to change the focus of Qt Designer's action editor

Allows you to include several custom widgets in one single library

Allows you to manipulate a widget's dynamic properties in Qt Designer's property editor

Allows you to query and modify a form window's widget selection, and in addition modify the properties of all the form's widgets

Allows you to manipulate the collection of form windows in Qt Designer, and control Qt Designer's form editing actions

Allows you to change the focus of Qt Designer's object inspector

Allows you to manipulate a widget's properties which is displayed in Qt Designer's property editor

Allows you to control the contents of Qt Designer's widget box

Rounded range control (like a speedometer or potentiometer)

Widget that presents buttons in a layout that is appropriate to the current widget style

Iterator for directory entrylists

Stores information about a host address record

Stores information about a DNS MX record

Stores information about a DNS TXT record

Represents one attribute of a QDomElement

Represents a generic string in the DOM

Represents an XML document

The representation of the DTD in the document tree

Represents an XML entity

Information about the features of the DOM implementation

The base class for all the nodes in a DOM tree

Represents an XML notation

Represents text data in the parsed XML document

Range checking of floating-point numbers

Event which is sent to a widget when a drag and drop action enters it

Event which is sent while a drag and drop action is in progress

This class provides encryption for UDP sockets

Contains event parameters for dynamic property change events

Fast way to calculate elapsed times

Contains parameters that describe an enter event

The base class of all event classes. Event objects contain event parameters

Means to quit an event loop when it is no longer needed

QObject-specific transition for Qt events

Represents a pointer to an explicitly shared object

Allows you to create a factory that is able to make instances of custom extensions in Qt Designer

Interface for reading from and writing to files

Dialog that allow users to select files or directories

System-independent file information

Convenient way of selecting file variants

Interface for monitoring files and directories for modifications

Helper data type for QFlags

Contains event parameters for widget focus events

Specifies a query for a font used for drawing text

Information about the fonts available in the underlying window system

General information about fonts

Font metrics information

Manages forms of input widgets and their associated labels

Represents the result of an asynchronous computation

Convenience class that simplifies QFuture synchronization

Internal helper class for marshalling arguments

Abstract base class for plugins

Internal helper class for marshalling arguments

The description of triggered gestures

Used to implement a global static object

Used in combination with QBrush to specify gradient fills

Layout where one can anchor widgets together in Graphics View

Colorize effect

The base class for all graphics effects

Grid layout for managing widgets in Graphics View

Container that treats a group of items as a single item

Can be inherited to allow your custom items to be managed by layouts

Horizontal or vertical layout for managing widgets in Graphics View

Opacity effect

Pixmap item that you can add to a QGraphicsScene

Proxy layer for embedding a QWidget in a QGraphicsScene

Rotation transformation around a given axis

Surface for managing a large number of 2D graphical items

Events for drag and drop in the graphics view framework

Events when a tooltip is requested

Mouse events in the graphics view framework

Events for widget resizing in the graphics view framework

Simple text path item that you can add to a QGraphicsScene

Text item that you can add to a QGraphicsScene to display formatted text

Widget for displaying the contents of a QGraphicsScene

Implements the Gregorian calendar

Group box frame with a title

Horizontal model mapper for bar series

Horizontal model mapper for box plot series

Horizontal model mapper for pie series

Template class that provides a hash-table-based dictionary

Header row or header column for item views

Item for use with QHelpContentModel

Tree view for displaying help content model items

The core functionality of the help system

Details for the filters used by QHelpFilterEngine

Widget that allows for creating, editing and removing filters

List view displaying the QHelpIndexModel

Access to widgets reusable to integrate fulltext search as well as to index and search documentation

The data associated with the search result

Event which is sent after a widget is hidden

Presents a series of data as horizontal bars grouped by category

Presents a series of data as horizontally stacked bars, with one bar per category

Static functions for host name lookups

Specifies that a host supports HTTP Strict Transport Security policy (HSTS)

Resembles a MIME multipart message to be sent over HTTP

The base interface class of all I/O devices in Qt

Scalable icons in different modes and states

Abstract base class for QIcon renderers

Proxies its source model unmodified

Defines the common image I/O interface for all image formats in Qt

Format independent interface for reading images from files or other devices

Describes a device from which a QInputEvent originates

The base class for events that describe user input

Parameters for input method events

Validator that ensures a string contains a valid integer within a specified range

Makes it possible to create item editor creator bases without subclassing QItemEditorCreatorBase

Widgets for editing item data in views and delegates

Proxy class for presenting data in item models with Q3DScatter

Manages information about selected items in a model

Manages information about a range of selected items in a model

Template class that allows iteration over a container in a QVariant

Represents a value on the JavaScript heap belonging to a QJSEngine

An empty marker type to signify the JavaScript Undefined type and its single value

Acts as a container for Qt/JavaScript data types

Jalali (Hijri Shamsi) calendar system implementation

Way to read and write JSON documents

Used to report errors during JSON parsing

Julian calendar system implementation

Describes a key event

Encapsulates a key sequence as used by shortcuts

Iterator over the key/value pairs of an associative container

Platform-independent little-endian integers

8-bit ASCII/Latin-1 character

The base class of geometry managers

Displays the legend of a chart

Loads shared libraries at runtime

Two-dimensional vector using integer precision

Two-dimensional vector using floating point precision

Used in combination with QBrush to specify a linear gradient brush

Java-style const iterator for QLinkedList

Java-style const iterator for QList and QQueue

Item-based list widget

Local socket based server

Converts between numbers and their string representations in various languages

Formatting rules for a logarithmic value axis

Represents a category, or 'area' in the logging infrastructure

Template class that provides an associative array

Defines the four margins of a rectangle

Represents a 4x4 transformation matrix in 3D space

Subwindow class for QMdiArea

Horizontal menu bar

Modal dialog for informing the user or for asking the user a question and receiving an answer

Generates log messages

Meta-data about an enumerator

Contains meta-information about Qt objects

Allows type erased access to sequential containers

Milanković calendar system implementation

Maintains a database of MIME types

Used to locate data in a data model

Span over QModelRoleData objects

Transition for mouse events

Convenience class for playing movies with QImageReader

Represents the central access communicating with an MQTT broker

Represents configuration options a QMqttClient can pass to the server when specifying the last will during connecting to a server

Represents additional information provided by the server during message delivery

Represents configuration options of a server a QMqttClient is connected to

Receives notifications from an MQTT broker about a specified topic

Represents a MQTT topic filter

Represents configuration options a QMqttClient can pass to the server when unsubscribing from a topic filter

Convenience QHash subclass that provides multi-valued hashes

Java-style const iterator for QMultiMap. QMultiMap has both Java-style iterators and STL-style iterators. STL-style iterators are more efficient and should be preferred

Java-style non-const iterator for QLinkedList

Java-style non-const iterator for QMap

Java-style non-const iterator for QSet

Convenience class that simplifies locking and unlocking mutexes

Native interface to a offscreen surface on Android

Native interface to an EGL context

Provides access to and enables adopting Direct3D 11 texture objects

Provides access to and enables adopting OpenGL texture objects

Native interface to a WGL context on Windows

Stores one IP address supported by a network interface, along with its associated netmask and broadcast address

Holds one network cookie

The data and metadata of a UDP datagram

Exposes various network information through native backends

Network layer proxy

Used to query the proxy settings for a socket

Holds a request to be sent with QNetworkAccessManager

Implements OAuth 1 signature methods

The base class of all Qt objects

Watches the lifetime of multiple QObjects

Represents an offscreen surface in the underlying platform

This class stores the necessary information to add a new reference on the server

Defines the identity of the application

OPC UA Argument type

OPC UA authentication information

Partial implementation of the OPC UA binary data encoding described in OPC-UA part 6

Contains parameters for a call to the OPC UA browse service

OPC UA ComplexNumber type

OPC UA ContentFilterElementResult

OPC UA DoubleComplexNumber type

OPC UA ElementOperand type

Allows investigation and interaction with error state from backends

OPC UA ExpandedNodeId

Handles communication with the GDS Server

OPC UA LiteralOperand type

Way to set and retrieve parameters for subscriptions and monitored items

Allows interaction with an OPC UA node

Defines the PKI configuration of the application

OPC UA QualifiedName type

This class stores the options for a read operation

Contains information about a node

OPC UA SimpleAttributeOperand type

This class stores the options for a write operation

Create a certificate signing request

Base class for all X509 extensions

Class for X509 extended key usage

Class for an X509 subject alternative name

Functions for creating and managing OpenGL buffer objects

Represents a group of contexts sharing OpenGL resources

Wraps an OpenGL debug message

Encapsulates an OpenGL framebuffer object

Cross-platform access to the OpenGL ES 2.0 API

All functions for OpenGL 1.1 specification

All functions for OpenGL 1.3 specification

All functions for OpenGL 1.5 specification

All functions for OpenGL 2.1 specification

All functions for OpenGL 3.1 specification

All functions for OpenGL 3.2 core profile

All functions for OpenGL 3.3 core profile

All functions for OpenGL 4.0 core profile

All functions for OpenGL 4.1 core profile

All functions for OpenGL 4.2 core profile

All functions for OpenGL 4.3 core profile

All functions for OpenGL 4.4 core profile

All functions for OpenGL 4.5 core profile

Enables painting to an OpenGL context using QPainter

Allows OpenGL shaders to be compiled

Encapsulates an OpenGL texture object

Wraps a sequence of OpenGL timer query objects

Provides access to OpenGL functions for a specified version and profile

Wraps an OpenGL Vertex Array Object

Convenience subclass of QWindow to perform OpenGL painting

Describes the size, orientation and margins of a page

Configuration dialog for the page-related options on a printer

Represents a paint device that supports multiple pages

Convenience subclass of QWindow that is also a QPaintDevice

Information about the active paint engine's current state

Performs low-level painting on widgets and other paint devices

Used to generate fillable outlines for a given painter path

Describes a panning gesture made by the user

Represents the result of a comparison that allows for unordered results

Class to generate PDFs that can be used as a paint device

Presents a series of categorized data as a percentage of each category

Paint device that records and replays QPainter commands

Presents data in pie charts

Describes a pinch gesture made by the user

Off-screen image representation that can be used as a paint device

Implements a plain text layout for QTextDocument

Used to notify about native platform surface events

Defines a point in the plane using integer precision

Template class that provides guarded pointers to QObject

Describes a device from which mouse, touch or tablet events originate

Presents data in polar charts

List of points using floating point precision

Defines an interface for how QPrinter interacts with a given printing subsystem

Widget for previewing page layouts for printer output

Gives access to information about existing printers

Holds the environment variables that can be passed to a program

Feedback on the progress of a slow operation

Template class that enables automatic property bindings

Controls the lifecycle of change callback installed on a QProperty

Convenience class that simplifies dynamically overriding QStyle elements

Allows you to control QML file loading

Encapsulates a QML component definition

Environment for instantiating QML components

Encapsulates a QML error

A class for applying a QFileSelector to QML file loading

Instances drive the progress of QQmlIncubators

Allows applications to expose list-like properties of QObject-derived classes to QML

Creates QNetworkAccessManager instances for a QML engine

Abstracts accessing properties on objects created from QML

Interface for property value sources such as animations and bindings

Represents a quaternion consisting of a vector and scalar

Helper class for selecting correct surface format

Base class for defining instance tables

Base class for defining custom texture data

Represents a set of colors

Container for low-level graphics settings that can affect how the underlying graphics API, such as Vulkan, is initialized by the Qt Quick scene graph. It can also control certain aspects of the scene graph renderer

Interface for supporting pixmaps and threaded image requests in QML

The most basic of all visual items in Qt Quick

Way to use the QPainter API in the QML Scene Graph

Opaque container for native graphics resources specifying a render target, and associated metadata

Access to the QTextDocument of QQuickTextEdit

Window for displaying a Qt Quick user interface

The window for displaying a graphical QML scene

Radio button with a text label

Allows one to obtain 64-bit random values from a high-quality, seed-less Random Number Generator

Convenience class for using QPainter on a QWindow

Convenience class that simplifies locking and unlocking read-write locks for read access

Defines a rectangle in the plane using integer precision

Access serialization between threads

Specifies a clip region for a painter

The results of a matching a QRegularExpression against a string

Used to check a string against a regular expression

Interface for reading directly from resources

Shared base for calendars based on the ancient Roman calendar

The base class for all runnable objects

Implements the clipping functionality in the scene graph

Convenient way of rendering solid colored geometry in the scene graph

Used for all rendered content in the scene graph

Encapsulates rendering state for a shader program

Used as a unique type token in combination with QSGMaterial

Used to change opacity of nodes

Convenience class for drawing solid filled rectangles using scenegraph

An interface providing access to some of the graphics API specific internals of the scenegraph

Provided for convenience to easily draw textured content using the QML scene graph

Convenient way of rendering textured geometry in the scene graph

Implements transformations in the scene graph

Interface for safely writing to files

Container for resolved data to be added to scatter graphs

Presents data in scatter charts

Stores a pointer to a dynamically allocated array of objects, and deletes it upon destruction

Resets a variable to its previous value on destruction

Scrolling view onto another widget

Sent when scrolling

Enables kinetic scrolling for any scrolling widget or graphics item

SCTP-based server

Compiler for SCXML files

The data model base class for a Qt SCXML state machine

Describes the errors returned by the Qt SCXML state machine when parsing an SCXML file

AssingmentInfo class represents a data assignment

Represents a foreach construct

Represents a parameter to a service invocation

Creates invokable service instances

Interface to the state machines created from SCXML files

Used by compiled state machines

Exception-safe deferral of a QSemaphore::release() call

Iterable interface for a container in a QVariant

Template class that provides a hash-table-based set

Persistent platform-independent application settings

Represents a pointer to an implicitly shared object

Holds a strong reference to a shared pointer

Event which is generated when the user presses a key combination

Exception-safe wrapper around QObject::blockSignals()

Enables introspection of signal emission

A base class for pointer events containing a single point, such as mouse events

Defines the size of a two-dimensional object using floating point precision

Layout attribute describing horizontal and vertical resizing policy

Support for monitoring activity on a file descriptor

Blank space in a layout

Splash screen that can be shown during application startup

Implements a splitter widget

Handles a connection to a database

Template class that provides a SQL driver factory for a specific driver type

Abstract base for custom QSqlDriver plugins

Manipulates the fields in SQL database tables and views

Means of executing and manipulating SQL statements

Encapsulates a database record

Delegate that is used to display and edit data from a QSqlRelationalTableModel

Abstract interface for accessing data from specific SQL databases

Convenient API for an X509 certificate

Represents an SSL cryptographic cipher

Interface for Diffie-Hellman parameters for servers

SSL error

Authentication data for pre shared keys (PSK) ciphersuites

Template class that provides a stack

Stack of widgets where only one widget is visible at a time

Item for use with the QStandardItemModel class

Generic model for storing custom data

General-purpose state for QStateMachine

Compile-time version of QByteArrayMatcher

Enables optimized drawing of text when the text and its layout is updated rarely

Event that is used to show messages in a status bar

Unicode character string

State-based decoder for text

List of strings

Holds a sequence of characters that can be quickly matched in a Unicode string

Splits strings into tokens along given separators

Abstract base class that encapsulates the look and feel of a GUI

Style hints that return more than basic data types

Style hints that return a QVariant

Stores the parameters used by QStyle functions

Used to describe the parameter for drawing a combobox

Used to describe the parameters for drawing a dock widget

Used to describe the parameters for drawing a frame

Describes the parameters for drawing a group box

Used to describe the parameters for drawing a header

Used to describe the parameters necessary for drawing a progress bar

Used to describe the parameter for drawing a size grip

Used to describe the parameters necessary for drawing a spin box

Used to describe the base of a tab bar, i.e. the part that the tab bar usually overlaps with

Used to describe the parameters for drawing a title bar

Used to describe the parameters needed for drawing a tool box

Used to describe the parameters used to draw an item in a view widget

Abstract base for custom QStyle plugins

Used when registering fonts with the internal Qt fontdatabase

Represents a data series in a 3D surface graph

The data proxy for a 3D surface graph

Paint device that is used to create SVG drawings

Widget that is used to display the contents of Scalable Vector Graphics (SVG) files

Allows you to define syntax highlighting rules, and in addition you can use the class to query a document's current formatting or user data

General counting system semaphore

Tab bar, e.g. for use in tabbed dialogs

Default model/view implementation of a table view

Item for use with the QTableWidget class

Contains parameters that describe a Tablet event

Describes a tap-and-hold (aka LongTap) gesture made by the user

TCP-based server

Creates a unique directory for temporary use

Used to simulate a sequence of touch events

Container for text fragments in a QTextDocument

Container for text blocks within a QTextDocument

Way of finding Unicode text boundaries in a string

Formatting information for characters in a QTextDocument

Offers an API to access and modify QTextDocuments

Holds formatted text

Format-independent interface for writing a QTextDocument to files or other devices

State-based encoder

Holds a piece of text in a QTextDocument with a single QTextCharFormat

Formatting information for frames in a QTextDocument

Represents an inline object in a QAbstractTextDocumentLayout and its implementations

Used to lay out and render text

Represents a line of text inside a QTextLayout

Formatting information for lists in a QTextDocument

Allows drawing of custom text objects in QTextDocuments

Convenient interface for reading and writing text

Represents the properties of a cell in a QTextTable

Formatting information for tables in a QTextDocument

Manages a collection of QThreads

The rules used to draw a pixmap or image split into nine segments

Widget for editing times based on the QDateTimeEdit widget

Converts between UTC and local time in a specific time zone

Contains parameters that describe a timer event

Column of tabbed widget items

Tool tips (balloon help) for any widget

Contains parameters that describe a touch event

Internationalization support for text output

Default model/view implementation of a tree view

Item for use with the QTreeWidget convenience class

Contains a lightweight representation of a version number with two 8-bit segments, major and minor, either of which can be unknown

Enables standalone applications to dynamically create user interfaces at run-time using the information stored in UI files or specified in plugin paths

Group of QUndoStack objects

Displays the contents of a QUndoStack

Uniform interface over bindable properties like QProperty\ and QObjectBindableProperty of any type T

Way to manipulate a key-value pairs in a URL's query

Stores a Universally Unique Identifier (UUID)

Lines up widgets vertically

Vertical model mapper for a candlestick series

Vertical model mapper for line, spline, and scatter series

Manipulates an axis of a graph

Adds values to a chart's axes

Acts like a union for the most common Qt data types

Emulated const pointer to QVariant based on a pointer

Acts as a non-const reference to a QVariant

Represents a vector or vertex in 2D space

Represents a vector or vertex in 4D space

Base class for input methods

Provides access to an input context

Acts as a hub for keyboard event notifications

Trace is a data model for touch input data

Represents information about a Vulkan extension

A specialized QList for QVulkanLayer and QVulkanExtension

Represents information about a Vulkan layer

Used to implement the application-specific rendering logic for a QVulkanWindow

Holds the reference to a surface buffer

Manages the Wayland display server

Extension for embedded-style user interfaces

Represents a keyboard device

Holds the resolution and refresh rate of an output

Provides access to input methods in the compositor

Provides support for shell surface integration with QtQuick

Access to keyboard, mouse, and touch input

Represents a rectangular area on an output device

Access to a touch device

Provides an extension for surface resizing and cropping

Desktop-style compositor-specific features to a surface

Provides an extension for describing outputs in a desktop oriented fashion

Extension for desktop-style user interfaces

Represents the toplevel window specific parts of an xdg surface

Simple description of any widget, i.e. answering the question "What's This?"

Contains parameters that describe a wheel event

Extends QAction by an interface for inserting custom widgets into action based containers, such as toolbars

Support for the Windows Wait functions

The window state before a window state change

The base class for wizard pages

Legend marker for a line, spline, or scatter series

XML attributes

Interface to report DTD content of XML data

Default implementation of all the XML handler classes

Interface to report errors in XML data

Interface to report the lexical content of XML data

Helper class for XML readers which want to include namespace support

Interface for XML readers (i.e. parsers)

Represents a single XML attribute

Represents a DTD entity declaration

Represents a namespace declaration

Fast parser for reading well-formed XML via a simple streaming API

An abstract base class for Qt3D animations

The base class for types providing animation playback capabilities

Performs an additive blend of two animation clips based on an additive factor

Represents an animation callback object

Class containing the animation data

A controller class for animations

Component providing animation playback capabilities of a tree of blend nodes

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

Allows to map the channels within the clip onto properties of objects in the application

Class used for including a clip in a blend tree

A class implementing simple keyframe animation to a QTransform

A class providing morph targets to blend-shape animation

A class implementing vertex-blend morphing animation

Abstract base class for all functors

Used to calculate skinning transform matrices and set them on shaders

Base class for jobs executed in an aspect

Base class for all Qt3D backend nodes

Can be used to override the bounding volume of an entity

Base class of scene nodes that can be aggregated by Qt3DCore::QEntity instances as a component

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

Encapsulates geometry details

The base class of all Qt3D node classes used to build a Qt3D scene

Holds the data for a skeleton to be used with skinned meshes

Used to perform transforms on meshes

Basic functionality for camera controllers

A conical mesh

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

A cuboid mesh

A cylindrical mesh

Default implementation of the phong lighting effect

A 3D extruded Text mesh

Default FrameGraph implementation of a forward renderer

Default implementation of PBR lighting

Allows controlling the scene camera along orbital path

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

A square planar mesh

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

A spherical mesh

Default implementation of a simple unlit texture material

A toroidal mesh

The base class for the Action Input and all Aggregate Action Inputs

The base class used by Qt3d to interact with arbitrary input devices

Links a set of QAbstractActionInput that trigger the same event

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

Processes velocity or acceleration data from a QAxis

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

Represents a set of QAbstractActionInput's that must be triggerd at once

Represents a set of QAbstractActionInput's that must be triggerd one after the other

Event type send by KeyBoardHandler

Provides keyboard event notification

Delegates mouse events to the attached MouseHandler objects

Provides a means of being notified about mouse events when attached to a QMouseDevice instance

Provides a way to have a synchronous function executed each frame

Encapsulate a QAbstractLight object in a Qt 3D scene

A base class to be used to provide textures

Enable alpha-to-coverage multisampling mode

Specifies the equation used for both the RGB blend equation and the Alpha blend equation

FrameGraph node to transfer a rectangle of pixel values from one region of a render target to another

Defines a view point through which the scene will be rendered

Class to allow for selection of camera to be used

Enables an additional OpenGL clipping plane that can be in shaders using gl_ClipDistance

QComponent to issue work for the compute shader on GPU

Enables a visual overlay with scene details

Tests the fragment shader's depth value against the depth of a sample being written to

FrameGraph node to issue work for the compute shader on GPU

Base class for effects in a Qt 3D scene

Storage for filter keys and their values

Defines front and back facing polygons

Encapsulates geometry rendering

Way of filtering which entities will be rendered

Way of controlling the complexity of rendered entities based on their size on the screen