QSGRenderNode Class

See also https://

flags QSGRenderNode::RenderingFlags

Possible values for the bitmask returned from https://().

The RenderingFlags type is a typedef for https://<RenderingFlag>. It stores an OR combination of RenderingFlag values.

See Also▲

flags QSGRenderNode::StateFlags

This enum is a bit mask identifying several states.

The StateFlags type is a typedef for https://<StateFlag>. It stores an OR combination of StateFlag values.

Destructs the render node. Derived classes are expected to perform cleanup similar to https://() in here.

When a low-level graphics API is in use, the scenegraph will make sure there is a CPU-side wait for the GPU to complete all work submitted to the scenegraph's graphics command queue before the scenegraph's nodes are deleted. Therefore there is no need to issue additional waits here, unless the https://() implementation is using additional command queues.

With https:// and resources such as https://, https://, https://, etc., it is often good practice to use smart pointers, such as std::unique_ptr, which can often avoid the need to implement a destructor, and lead to more compact source code. Keep in mind however that implementing https://(), most likely issuing a number of reset() calls on the unique_ptrs, is still important.

See Also▲

When the underlying rendering API is OpenGL, this function should return a mask where each bit represents graphics states changed by the https://() function:

With APIs other than OpenGL, the only relevant values are the ones that correspond to dynamic state changes recorded on the command list/buffer. For example, RSSetViewports, RSSetScissorRects, OMSetBlendState, OMSetDepthStencilState in case of D3D11, or vkCmdSetViewport, vkCmdSetScissor, vkCmdSetBlendConstants, vkCmdSetStencilRef in case of Vulkan, and only when such commands were added to the scenegraph's command list queried via the QSGRendererInterface::CommandList resource enum. States set in pipeline state objects do not need to be reported here. Similarly, draw call related settings (pipeline states, descriptor sets, vertex or index buffer bindings, root signature, descriptor heaps, etc.) are always set again by the scenegraph so https://() can freely change them.

https:// is no longer supported with APIs like Vulkan. This is by nature. https://() is invoked while the Qt Quick scenegraph's main command buffer is recording a renderpass, so there is no possibility of changing the target and starting another renderpass (on that command buffer at least). Therefore returning a value with https:// set is not sensible.

The function is called by the renderer so it can reset the states after rendering this node. This makes the implementation of https://() simpler since it does not have to query and restore these states.

The default implementation returns 0, meaning no relevant state was changed in https://().

Returns the current clip list.

Returns the current command buffer.

This function was introduced in Qt 6.6.

See Also▲

Returns flags describing the behavior of this render node.

The default implementation returns 0.

See Also▲

Returns the current effective opacity.

Returns pointer to the current model-view matrix.

Called from the frame preparation phase. There is a call to this function before each invocation of https://().

Unlike https://(), this function is called before the scenegraph starts recording the render pass for the current frame on the underlying command buffer. This is useful when doing rendering with graphics APIs, such as Vulkan, where copy type of operations will need to be recorded before the render pass.

The default implementation is empty.

When implementing a https:// that uses https:// to render, query the https:// object from the https:// via https://(). To get a https:// for submitting work to, call https://(). To query information about the active render target, call https://(). See the https:// example for details.

This function was introduced in Qt 6.0.

Returns pointer to the current projection matrix.

In https://() this is the same matrix that is returned from https://(). This getter exists so that https://() also has a way to query the projection matrix.

When working with a modern graphics API, or Qt's own graphics abstraction layer, it is more than likely that one will want to load *projectionMatrix() * *matrix() into a uniform buffer. That is however something that needs to be done in https://(), so outside the recording of a render pass. That is why both matrices are queriable directly from the https://, both in https://() and https://().

This function was introduced in Qt 6.5.

Returns the bounding rectangle in item coordinates for the area https://() touches. The value is only in use when https://() includes https://, ignored otherwise.

Reporting the rectangle in combination with https:// is particularly important with the software backend because otherwise having a rendernode in the scene would trigger fullscreen updates, skipping all partial update optimizations.

For rendernodes covering the entire area of a corresponding https:// the return value will be (0, 0, item->https://, item->https://).

See Also▲

This function is called when all custom graphics resources allocated by this node have to be freed immediately. In case the node does not directly allocate graphics resources (buffers, textures, render targets, fences, etc.) through the graphics API that is in use, there is nothing to do here.

Failing to release all custom resources can lead to incorrect behavior in graphics device loss scenarios on some systems since subsequent reinitialization of the graphics system may fail.

Unlike with the destructor, it is expected that https://() can reinitialize all resources it needs when called after a call to releaseResources().

With OpenGL, the scenegraph's OpenGL context will be current both when calling the destructor and this function.

This function is called by the renderer and should paint this node with directly invoking commands in the graphics API (OpenGL, Direct3D, etc.) currently in use.

The effective opacity can be retrieved with https://().

The projection matrix is available through state, while the model-view matrix can be fetched with https://(). The combined matrix is then the projection matrix times the model-view matrix. The correct stacking of the items in the scene is ensured by the projection matrix.

When using the provided matrices, the coordinate system for vertex data follows the usual https:// conventions: top-left is (0, 0), bottom-right is the corresponding https://'s https:// and https:// minus one. For example, assuming a two float (x-y) per vertex coordinate layout, a triangle covering half of the item can be specified as (width - 1, height - 1), (0, 0), (0, height - 1) using counter-clockwise direction.

Clip information is calculated before the function is called. Implementations wishing to take clipping into account can set up scissoring or stencil based on the information in state. The stencil buffer is filled with the necessary clip shapes, but it is up to the implementation to enable stencil testing.

Some scenegraph backends, software in particular, use no scissor or stencil. There the clip region is provided as an ordinary https://.

When implementing a https:// that uses https:// to render, query the https:// object from the https:// via https://(). To get a https:// for submitting work to, call https://(). To query information about the active render target, call https://(). See the https:// example for details.

With Qt 6 and its https://-based scene graph renderer, no assumptions should be made about the active (OpenGL) state when this function is called, even when OpenGL is in use. Assume nothing about the pipelines and dynamic states bound on the command list/buffer when this function is called.

With some graphics APIs, including when using https:// directly, it can be necessary to reimplement https://() in addition, or alternatively connect to the https://() signal. These are called/emitted before recording the beginning of a renderpass on the command buffer (vkCmdBeginRenderPass with Vulkan, or starting to encode via MTLRenderCommandEncoder in case of Metal. Recording copy operations cannot be done inside render() with such APIs. Rather, do such operations either in https://() or the slot connected to beforeRendering (with DirectConnection).

See Also▲

Returns the current render target.

This is provided mainly to enable https://() and https://() implementations that use https:// accessing the https://'s https:// or pixel size.

To build a https://, which implies having to provide a https://, query the renderPassDescriptor from the render target. Be aware however that the render target may change over the lifetime of the custom https:// and the https://. For example, consider what happens when dynamically setting layer.enabled: true on the item or an ancestor of it: this triggers rendering into a texture, not directly to the window, which means the https:// is going to work with a different render target from then on. The new render target may then have a different pixel format, which can make already built graphics pipelines incompatible. This can be handled with logic such as the following:

if (m_pipeline && renderTarget()->renderPassDescriptor()->serializedFormat() != m_renderPassFormat) {
    delete m_pipeline;
    m_pipeline = nullptr;
}
if (!m_pipeline) {
    // Build a new QRhiGraphicsPipeline.
    // ...
    // Store the serialized format for fast and simple comparisons later on.
    m_renderPassFormat = renderTarget()->renderPassDescriptor()->serializedFormat();
}

This function was introduced in Qt 6.6.

See Also▲