PySide6.QtGui.QRhiSwapChain¶

class QRhiSwapChain¶

Swapchain resource.

Details

A swapchain enables presenting rendering results to a surface. A swapchain is typically backed by a set of color buffers. Of these, one is displayed at a time.

Below is a typical pattern for creating and managing a swapchain and some associated resources in order to render onto a QWindow :

void init()
{
    sc = rhi->newSwapChain();
    ds = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil,
                              QSize(), // no need to set the size here due to UsedWithSwapChainOnly
                              1,
                              QRhiRenderBuffer::UsedWithSwapChainOnly);
    sc->setWindow(window);
    sc->setDepthStencil(ds);
    rp = sc->newCompatibleRenderPassDescriptor();
    sc->setRenderPassDescriptor(rp);
    resizeSwapChain();
}

void resizeSwapChain()
{
    hasSwapChain = sc->createOrResize();
}

void render()
{
    if (!hasSwapChain || notExposed)
        return;

    if (sc->currentPixelSize() != sc->surfacePixelSize() || newlyExposed) {
        resizeSwapChain();
        if (!hasSwapChain)
            return;
        newlyExposed = false;
    }

    rhi->beginFrame(sc);
    // ...
    rhi->endFrame(sc);
}

Avoid relying on QWindow resize events to resize swapchains, especially considering that surface sizes may not always fully match the QWindow reported dimensions. The safe, cross-platform approach is to do the check via surfacePixelSize() whenever starting a new frame.

Releasing the swapchain must happen while the QWindow and the underlying native window is fully up and running. Building on the previous example:

void releaseSwapChain()
{
    if (hasSwapChain) {
        sc->destroy();
        hasSwapChain = false;
    }
}

// assuming Window is our QWindow subclass
bool Window::event(QEvent *e)
{
    switch (e->type()) {
    case QEvent::UpdateRequest: // for QWindow::requestUpdate()
        render();
        break;
    case QEvent::PlatformSurface:
        if (static_cast<QPlatformSurfaceEvent *>(e)->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed)
            releaseSwapChain();
        break;
    default:
        break;
    }
    return QWindow::event(e);
}

Initializing the swapchain and starting to render the first frame cannot start at any time. The safe, cross-platform approach is to rely on expose events. QExposeEvent is a loosely specified event that is sent whenever a window gets mapped, obscured, and resized, depending on the platform.

void Window::exposeEvent(QExposeEvent *)
{
    // initialize and start rendering when the window becomes usable for graphics purposes
    if (isExposed() && !running) {
        running = true;
        init();
    }

    // stop pushing frames when not exposed or size becomes 0
    if ((!isExposed() || (hasSwapChain && sc->surfacePixelSize().isEmpty())) && running)
        notExposed = true;

    // continue when exposed again and the surface has a valid size
    if (isExposed() && running && notExposed && !sc->surfacePixelSize().isEmpty()) {
        notExposed = false;
        newlyExposed = true;
    }

    if (isExposed() && !sc->surfacePixelSize().isEmpty())
        render();
}

Once the rendering has started, a simple way to request a new frame is requestUpdate() . While on some platforms this is merely a small timer, on others it has a specific implementation: for instance on macOS or iOS it may be backed by CVDisplayLink . The example above is already prepared for update requests by handling QEvent::UpdateRequest.

While acting as a QRhiRenderTarget , QRhiSwapChain also manages a QRhiCommandBuffer . Calling endFrame() submits the recorded commands and also enqueues a present request. The default behavior is to do this with a swap interval of 1, meaning synchronizing to the display’s vertical refresh is enabled. Thus the rendering thread calling beginFrame() and endFrame() will get throttled to vsync. On some backends this can be disabled by passing QRhiSwapChain : NoVSync in flags() .

Multisampling (MSAA) is handled transparently to the applications when requested via setSampleCount() . Where applicable, QRhiSwapChain will take care of creating additional color buffers and issuing a multisample resolve command at the end of a frame. For OpenGL, it is necessary to request the appropriate sample count also via QSurfaceFormat , by calling setDefaultFormat() before initializing the QRhi .

Note

This is a RHI API with limited compatibility guarantees, see QRhi for details.

Added in version 6.6.

Synopsis¶

Virtual methods¶

def createOrResize()
def currentFrameCommandBuffer()
def currentFrameRenderTarget()
def isFormatSupported()
def newCompatibleRenderPassDescriptor()
def surfacePixelSize()

Note

This documentation may contain snippets that were automatically translated from C++ to Python. We always welcome contributions to the snippet translation. If you see an issue with the translation, you can also let us know by creating a ticket on https:/bugreports.qt.io/projects/PYSIDE

class Flag¶

(inherits enum.Flag) Flag values to describe swapchain properties

Constant

Description

QRhiSwapChain.Flag.SurfaceHasPreMulAlpha

Indicates that the target surface has transparency with premultiplied alpha. For example, this is what Qt Quick uses when the alpha channel is enabled on the target QWindow , because the scenegraph rendrerer always outputs fragments with alpha multiplied into the red, green, and blue values. To ensure identical behavior across platforms, always set alphaBufferSize() to a non-zero value on the target QWindow whenever this flag is set on the swapchain.

QRhiSwapChain.Flag.SurfaceHasNonPreMulAlpha

Indicates the target surface has transparency with non-premultiplied alpha. Be aware that this may not be supported on some systems, if the system compositor always expects content with premultiplied alpha. In that case the behavior with this flag set is expected to be equivalent to SurfaceHasPreMulAlpha.

QRhiSwapChain.Flag.sRGB

Requests to pick an sRGB format for the swapchain’s color buffers and/or render target views, where applicable. Note that this implies that sRGB framebuffer update and blending will get enabled for all content targeting this swapchain, and opting out is not possible. For OpenGL, set sRGBColorSpace on the QSurfaceFormat of the QWindow in addition. Applicable only when the swapchain format is set to SDR .

QRhiSwapChain.Flag.UsedAsTransferSource

Indicates the swapchain will be used as the source of a readback in readBackTexture() .

QRhiSwapChain.Flag.NoVSync

Requests disabling waiting for vertical sync, also avoiding throttling the rendering thread. The behavior is backend specific and applicable only where it is possible to control this. Some may ignore the request altogether. For OpenGL, try instead setting the swap interval to 0 on the QWindow via setSwapInterval() .

QRhiSwapChain.Flag.MinimalBufferCount

Requests creating the swapchain with the minimum number of buffers, which is in practice 2, unless the graphics implementation has a higher minimum number than that. Only applicable with backends where such control is available via the graphics API, for example, Vulkan. By default it is up to the backend to decide what number of buffers it requests (in practice this is almost always either 2 or 3), and it is not the applications’ concern. However, on Vulkan for instance the backend will likely prefer the higher number (3), for example to avoid odd performance issues with some Vulkan implementations on mobile devices. It could be that on some platforms it can prove to be beneficial to force the lower buffer count (2), so this flag allows forcing that. Note that all this has no effect on the number of frames kept in flight, so the CPU ( QRhi ) will still prepare frames at most N - 1 frames ahead of the GPU, even when the swapchain image buffer count larger than N. (N = FramesInFlight and typically 2).

Constant	Description
QRhiSwapChain.Flag.SurfaceHasPreMulAlpha	Indicates that the target surface has transparency with premultiplied alpha. For example, this is what Qt Quick uses when the alpha channel is enabled on the target `QWindow` , because the scenegraph rendrerer always outputs fragments with alpha multiplied into the red, green, and blue values. To ensure identical behavior across platforms, always set `alphaBufferSize()` to a non-zero value on the target `QWindow` whenever this flag is set on the swapchain.
QRhiSwapChain.Flag.SurfaceHasNonPreMulAlpha	Indicates the target surface has transparency with non-premultiplied alpha. Be aware that this may not be supported on some systems, if the system compositor always expects content with premultiplied alpha. In that case the behavior with this flag set is expected to be equivalent to SurfaceHasPreMulAlpha.
QRhiSwapChain.Flag.sRGB	Requests to pick an sRGB format for the swapchain’s color buffers and/or render target views, where applicable. Note that this implies that sRGB framebuffer update and blending will get enabled for all content targeting this swapchain, and opting out is not possible. For OpenGL, set `sRGBColorSpace` on the `QSurfaceFormat` of the `QWindow` in addition. Applicable only when the swapchain format is set to `SDR` .
QRhiSwapChain.Flag.UsedAsTransferSource	Indicates the swapchain will be used as the source of a readback in `readBackTexture()` .
QRhiSwapChain.Flag.NoVSync	Requests disabling waiting for vertical sync, also avoiding throttling the rendering thread. The behavior is backend specific and applicable only where it is possible to control this. Some may ignore the request altogether. For OpenGL, try instead setting the swap interval to 0 on the `QWindow` via `setSwapInterval()` .
QRhiSwapChain.Flag.MinimalBufferCount	Requests creating the swapchain with the minimum number of buffers, which is in practice 2, unless the graphics implementation has a higher minimum number than that. Only applicable with backends where such control is available via the graphics API, for example, Vulkan. By default it is up to the backend to decide what number of buffers it requests (in practice this is almost always either 2 or 3), and it is not the applications’ concern. However, on Vulkan for instance the backend will likely prefer the higher number (3), for example to avoid odd performance issues with some Vulkan implementations on mobile devices. It could be that on some platforms it can prove to be beneficial to force the lower buffer count (2), so this flag allows forcing that. Note that all this has no effect on the number of frames kept in flight, so the CPU ( `QRhi` ) will still prepare frames at most `N - 1` frames ahead of the GPU, even when the swapchain image buffer count larger than `N`. (`N` = `FramesInFlight` and typically 2).

class Format¶

Describes the swapchain format. The default format is SDR.

This enum is used with isFormatSupported() to check upfront if creating the swapchain with the given format is supported by the platform and the window’s associated screen, and with setFormat() to set the requested format in the swapchain before calling createOrResize() for the first time.

Constant

Description

QRhiSwapChain.Format.SDR

8-bit RGBA or BGRA, depending on the backend and platform. With OpenGL ES in particular, it could happen that the platform provides less than 8 bits (e.g. due to EGL and the QSurfaceFormat choosing a 565 or 444 format - this is outside the control of QRhi ). Standard dynamic range. May be combined with setting the sRGB flag.

QRhiSwapChain.Format.HDRExtendedSrgbLinear

16-bit float RGBA, high dynamic range, extended linear sRGB (scRGB) color space. This involves Rec. 709 primaries (same as SDR/sRGB) and linear colors. Conversion to the display’s native color space (such as, HDR10) is performed by the windowing system. On Windows this is the canonical color space of the system compositor, and is the recommended format for HDR swapchains in general on desktop platforms.

QRhiSwapChain.Format.HDR10

10-bit unsigned int RGB or BGR with 2 bit alpha, high dynamic range, HDR10 (Rec. 2020) color space with an ST2084 PQ transfer function.

QRhiSwapChain.Format.HDRExtendedDisplayP3Linear

16-bit float RGBA, high dynamic range, extended linear Display P3 color space. The primary choice for HDR on platforms such as iOS and VisionOS.

Constant	Description
QRhiSwapChain.Format.SDR	8-bit RGBA or BGRA, depending on the backend and platform. With OpenGL ES in particular, it could happen that the platform provides less than 8 bits (e.g. due to EGL and the `QSurfaceFormat` choosing a 565 or 444 format - this is outside the control of `QRhi` ). Standard dynamic range. May be combined with setting the `sRGB` flag.
QRhiSwapChain.Format.HDRExtendedSrgbLinear	16-bit float RGBA, high dynamic range, extended linear sRGB (scRGB) color space. This involves Rec. 709 primaries (same as SDR/sRGB) and linear colors. Conversion to the display’s native color space (such as, HDR10) is performed by the windowing system. On Windows this is the canonical color space of the system compositor, and is the recommended format for HDR swapchains in general on desktop platforms.
QRhiSwapChain.Format.HDR10	10-bit unsigned int RGB or BGR with 2 bit alpha, high dynamic range, HDR10 (Rec. 2020) color space with an ST2084 PQ transfer function.
QRhiSwapChain.Format.HDRExtendedDisplayP3Linear	16-bit float RGBA, high dynamic range, extended linear Display P3 color space. The primary choice for HDR on platforms such as iOS and VisionOS.

class StereoTargetBuffer¶

Selects the backbuffer to use with a stereoscopic swapchain.

Constant

Description

QRhiSwapChain.StereoTargetBuffer.LeftBuffer

QRhiSwapChain.StereoTargetBuffer.RightBuffer

Constant	Description
QRhiSwapChain.StereoTargetBuffer.LeftBuffer
QRhiSwapChain.StereoTargetBuffer.RightBuffer

PySide6.QtGui.QRhiSwapChain.m_window¶

PySide6.QtGui.QRhiSwapChain.m_flags¶

PySide6.QtGui.QRhiSwapChain.m_format¶

PySide6.QtGui.QRhiSwapChain.m_depthStencil¶

PySide6.QtGui.QRhiSwapChain.m_sampleCount¶

PySide6.QtGui.QRhiSwapChain.m_renderPassDesc¶

PySide6.QtGui.QRhiSwapChain.m_currentPixelSize¶

abstract createOrResize()¶

Return type:: bool

Creates the swapchain if not already done and resizes the swapchain buffers to match the current size of the targeted surface. Call this whenever the size of the target surface is different than before.

Note

call destroy() only when the swapchain needs to be released completely, typically upon SurfaceAboutToBeDestroyed . To perform resizing, just call createOrResize().

Returns true when successful, false when a graphics operation failed. Regardless of the return value, calling destroy() is always safe.

abstract currentFrameCommandBuffer()¶

Return type:: QRhiCommandBuffer

Returns a command buffer on which rendering commands and resource updates can be recorded within a beginFrame - endFrame block, assuming beginFrame() was called with this swapchain.

Note

The returned object is valid also after endFrame(), up until the next beginFrame(), but the returned command buffer should not be used to record any commands then. Rather, it can be used to query data collected during the frame (or previous frames), for example by calling lastCompletedGpuTime() .

Note

The value must not be cached and reused between frames. The caller should not hold on to the returned object once beginFrame() is called again. Instead, the command buffer object should be queried again by calling this function.

abstract currentFrameRenderTarget()¶

Return type:: QRhiRenderTarget

Returns a render target that can used with beginPass() in order to render the swapchain’s current backbuffer. Only valid within a beginFrame() - endFrame() block where beginFrame() was called with this swapchain.

Note

the value must not be cached and reused between frames

currentFrameRenderTarget(targetBuffer)

Parameters:: targetBuffer – StereoTargetBuffer
Return type:: QRhiRenderTarget

Returns a render target that can be used with beginPass() in order to render to the swapchain’s left or right backbuffer. This overload should be used only with stereoscopic rendering, that is, when the associated QWindow is backed by two color buffers, one for each eye, instead of just one.

When stereoscopic rendering is not supported, the return value will be the default target. It is supported by all hardware backends except for Metal, in combination with StereoBuffers , assuming it is supported by the graphics and display driver stack at run time. Metal and Null backends are going to return the default render target from this overload.

Note

the value must not be cached and reused between frames

currentPixelSize()¶

Return type:: QSize

Returns the size with which the swapchain was last successfully built. Use this to decide if createOrResize() needs to be called again: if currentPixelSize() != surfacePixelSize() then the swapchain needs to be resized.

Note

Typical rendering logic will call this function to get the output size when starting to prepare a new frame, and base dependent calculations (such as, the viewport) on the size returned from this function.

While in many cases the value is the same as QWindow::size() * QWindow::devicePixelRatio(), relying on the QWindow -reported size is not guaranteed to be correct on all platforms and graphics API implementations. Using this function is therefore strongly recommended whenever there is a need to identify the dimensions, in pixels, of the output layer or surface.

This also has the added benefit of avoiding potential data races when QRhi is used on a dedicated rendering thread, because the need to call QWindow functions, that may then access data updated on the main thread, is avoided.

See also

surfacePixelSize()

depthStencil()¶

Return type:: QRhiRenderBuffer

Returns the currently associated renderbuffer for depth-stencil.

See also

setDepthStencil()

flags()¶

Return type:: Combination of Flag

Returns the currently set flags.

See also

setFlags()

format()¶

Return type:: Format

Returns the currently set format.

See also

setFormat()

abstract isFormatSupported(f)¶

Parameters:: f – Format
Return type:: bool

Returns true if the given swapchain format f is supported. SDR is always supported.

Note

Can be called independently of createOrResize() , but window() must already be set. Calling without the window set may lead to unexpected results depending on the backend and platform (most likely false for any HDR format), because HDR format support is usually tied to the output (screen) to which the swapchain’s associated window belongs at any given time. If the result is true for a HDR format, then creating the swapchain with that format is expected to succeed as long as the window is not moved to another screen in the meantime.

The main use of this function is to call it before the first createOrResize() after the window is already set. This allow the QRhi backends to perform platform or windowing system specific queries to determine if the window (and the screen it is on) is capable of true HDR output with the specified format.

When the format is reported as supported, call setFormat() to set the requested format and call createOrResize() . Be aware of the consequences however: successfully requesting a HDR format will involve having to deal with a different color space, possibly doing white level correction for non-HDR-aware content, adjusting tonemapping methods, adjusting offscreen render target settings, etc.

See also

setFormat()

abstract newCompatibleRenderPassDescriptor()¶

Return type:: QRhiRenderPassDescriptor

Returns a new QRhiRenderPassDescriptor that is compatible with this swapchain.

The returned value is used in two ways: it can be passed to setRenderPassDescriptor() and setRenderPassDescriptor() . A render pass descriptor describes the attachments (color, depth/stencil) and the load/store behavior that can be affected by flags() . A QRhiGraphicsPipeline can only be used in combination with a swapchain that has a compatible QRhiRenderPassDescriptor set.

See also

createOrResize()

renderPassDescriptor()¶

Return type:: QRhiRenderPassDescriptor

Returns the currently associated QRhiRenderPassDescriptor object.

See also

setRenderPassDescriptor()

sampleCount()¶

Return type:: int

Returns the currently set sample count. 1 means no multisample antialiasing.

See also

setSampleCount()

setDepthStencil(ds)¶

Parameters:: ds – QRhiRenderBuffer

Sets the renderbuffer ds for use as a depth-stencil buffer.

See also

depthStencil()

setFlags(f)¶

Parameters:: f – Combination of Flag

Sets the flags f.

See also

flags()

setFormat(f)¶

Parameters:: f – Format

Sets the format f.

Avoid setting formats that are reported as unsupported from isFormatSupported() . Note that support for a given format may depend on the screen the swapchain’s associated window is opened on. On some platforms, such as Windows and macOS, for HDR output to work it is necessary to have HDR output enabled in the display settings.

See isFormatSupported() , QRhiSwapChainHdrInfo , and Format for more information on high dynamic range output.

See also

format()

setRenderPassDescriptor(desc)¶

Parameters:: desc – QRhiRenderPassDescriptor

Associates with the QRhiRenderPassDescriptor desc.

See also

renderPassDescriptor()

setSampleCount(samples)¶

Parameters:: samples – int

Sets the sample count. Common values for samples are 1 (no MSAA), 4 (4x MSAA), or 8 (8x MSAA).

See also

sampleCount() supportedSampleCounts()

setWindow(window)¶

Parameters:: window – QWindow

Sets the window.

See also

window()

abstract surfacePixelSize()¶

Return type:: QSize

Returns The size of the window’s associated surface or layer.

Warning

Do not assume this is the same as QWindow::size() * QWindow::devicePixelRatio(). With some graphics APIs and windowing system interfaces (for example, Vulkan) there is a theoretical possibility for a surface to assume a size different from the associated window. To support these cases, rendering logic must always base size-derived calculations (such as, viewports) on the size reported from QRhiSwapChain , and never on the size queried from QWindow ****.

Note

Can also be called before createOrResize() , if at least window() is already set. This in combination with currentPixelSize() allows to detect when a swapchain needs to be resized. However, watch out for the fact that the size of the underlying native object (surface, layer, or similar) is “live”, so whenever this function is called, it returns the latest value reported by the underlying implementation, without any atomicity guarantee. Therefore, using this function to determine pixel sizes for graphics resources that are used in a frame is strongly discouraged. Rely on currentPixelSize() instead which returns a size that is atomic and will not change between createOrResize() invocations.

Note

For depth-stencil buffers used in combination with the swapchain’s color buffers, it is strongly recommended to rely on the automatic sizing and rebuilding behavior provided by the QRhiRenderBuffer :UsedWithSwapChainOnly flag. Avoid querying the surface size via this function just to get a size that can be passed to setPixelSize() as that would suffer from the lack of atomicity as described above.