- class QQuickWindow¶
The
QQuickWindow
class provides the window for displaying a graphical QML scene. More…Inherited by:
QQuickView
Synopsis¶
Properties¶
activeFocusItemᅟ
- Item which currently has active focus or null if there is no item with active focuscolorᅟ
- Used to clear the color buffer at the beginning of each framecontentItemᅟ
- Invisible root item of the scene
Methods¶
def
__init__()
def
color()
def
contentItem()
def
createTextNode()
def
grabWindow()
def
graphicsDevice()
def
renderTarget()
def
rhi()
def
setColor()
def
swapChain()
Slots¶
def
update()
Signals¶
def
afterAnimating()
def
afterFrameEnd()
def
afterRendering()
def
colorChanged()
def
frameSwapped()
def
paletteChanged()
def
paletteCreated()
Static functions¶
def
graphicsApi()
def
setGraphicsApi()
def
textRenderType()
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
Detailed Description¶
QQuickWindow
provides the graphical scene management needed to interact with and display a scene of QQuickItems.A
QQuickWindow
always has a single invisible root item. To add items to this window, reparent the items to the root item or to an existing item in the scene.For easily displaying a scene from a QML file, see
QQuickView
.Rendering¶
QQuickWindow
uses a scene graph to represent what needs to be rendered. This scene graph is disconnected from the QML scene and potentially lives in another thread, depending on the platform implementation. Since the rendering scene graph lives independently from the QML scene, it can also be completely released without affecting the state of the QML scene.The
sceneGraphInitialized()
signal is emitted on the rendering thread before the QML scene is rendered to the screen for the first time. If the rendering scene graph has been released, the signal will be emitted again before the next frame is rendered. A visible, on-screenQQuickWindow
is driven internally by arender loop
, of which there are multiple implementations provided in the scene graph. For details on the scene graph rendering process, see Qt Quick Scene Graph .By default, a
QQuickWindow
renders using an accelerated 3D graphics API, such as OpenGL or Vulkan. See Scene Graph Adaptations for a detailed overview of scene graph backends and the supported graphics APIs.Warning
It is crucial that graphics operations and interaction with the scene graph happens exclusively on the rendering thread, primarily during the updatePaintNode() phase.
Warning
As many of the signals related to rendering are emitted from the rendering thread, connections should be made using Qt::DirectConnection.
Integration with Accelerated 3D Graphics APIs¶
It is possible to integrate OpenGL, Vulkan, Metal, or Direct3D 11 calls directly into the
QQuickWindow
, as long as theQQuickWindow
and the underlying scene graph is rendering using the same API. To access native graphics objects, such as device or context object handles, useQSGRendererInterface
. An instance ofQSGRendererInterface
is queriable fromQQuickWindow
by callingrendererInterface()
. The enablers for this integration are thebeforeRendering()
,beforeRenderPassRecording()
,afterRenderPassRecording()
, and related signals. These allow rendering underlays or overlays. Alternatively,QSGOpenGLTexture
,QSGVulkanTexture
, and other similar classes allow wrapping an existing native texture or image object in aQSGTexture
that can then be used with the scene graph.Rendering without Acceleration¶
A limited, pure software based rendering path is available as well. With the
software
backend, a number of Qt Quick features are not available, QML items relying on these will not be rendered at all. At the same time, this allowsQQuickWindow
to be functional even on systems where there is no 3D graphics API available at all. See Qt Quick Software Adaptation for more details.Redirected Rendering¶
A
QQuickWindow
is not necessarily backed by a native window on screen. The rendering can be redirected to target a custom render target, such as a given native texture. This is achieved in combination with theQQuickRenderControl
class, and functions such assetRenderTarget()
,setGraphicsDevice()
, andsetGraphicsConfiguration()
.In this case, the
QQuickWindow
represents the scene, and provides the intrastructure for rendering a frame. It will not be backed by a render loop and a native window. Instead, in this case the application drives rendering, effectively substituting for the render loops. This allows generating image sequences, rendering into textures for use in external 3D engines, or rendering Qt Quick content within a VR environment.Resource Management¶
QML will try to cache images and scene graph nodes to improve performance, but in some low-memory scenarios it might be required to aggressively release these resources. The
releaseResources()
function can be used to force the clean up of certain resources, especially resource that are cached and can be recreated later when needed again.Additionally, calling
releaseResources()
may result in releasing the entire scene graph and the associated graphics resources. ThesceneGraphInvalidated()
signal will be emitted when this happens. This behavior is controlled by thesetPersistentGraphics()
andsetPersistentSceneGraph()
functions.Note
All classes with QSG prefix should be used solely on the scene graph’s rendering thread. See Scene Graph and Rendering for more information.
Exposure and Visibility¶
When a
QQuickWindow
instance is deliberately hidden with hide() or setVisible(false), it will stop rendering and its scene graph and graphics context might be released as well. This depends on the settings configured bysetPersistentGraphics()
andsetPersistentSceneGraph()
. The behavior in this respect is identical to explicitly calling thereleaseResources()
function. A window can become not exposed, in other words non-renderable, by other means as well. This depends on the platform and windowing system. For example, on Windows minimizing a window makes it stop rendering. On macOS fully obscuring a window by other windows on top triggers the same. On Linux/X11, the behavior is dependent on the window manager.OpenGL Context and Surface Formats¶
While it is possible to specify a QSurfaceFormat for every
QQuickWindow
by calling the member function setFormat(), windows may also be created from QML by using the Window and ApplicationWindow elements. In this case there is no C++ code involved in the creation of the window instance, yet applications may still wish to set certain surface format values, for example to request a given OpenGL version or profile. Such applications can call the static function QSurfaceFormat::setDefaultFormat() at startup. The specified format will be used for all Quick windows created afterwards.Vulkan Instance¶
When using Vulkan, a
QQuickWindow
is automatically associated with a QVulkanInstance that is created and managed internally by the scene graph. This way most applications do not need to worry about having aVkInstance
available since it all happens automatically. In advanced cases an application may wish to create its own QVulkanInstance, in order to configure it in a specific way. That is possible as well. Calling setVulkanInstance() on theQQuickWindow
right after construction, before making it visible, leads to using the application-supplied QVulkanInstance (and the underlyingVkInstance
). When redirecting viaQQuickRenderControl
, there is no QVulkanInstance provided automatically, but rather the application is expected to provide its own and associate it with theQQuickWindow
.Graphics Contexts and Devices¶
When the scene graph is initialized, which typically happens when the window becomes exposed or, in case of redirected rendering, initialization is performed
via QQuickRenderControl
, the context or device objects necessary for rendering are created automatically. This includes OpenGL contexts, Direct3D devices and device contexts, Vulkan and Metal devices. These are also queriable by application code afterwards viaQSGRendererInterface
. When using thebasic
render loop, which performs all rendering on the GUI thread, the same context or device is used with all visible QQuickWindows. Thethreaded
render loop uses a dedicated context or device object for each rendering thread, and so for eachQQuickWindow
. With some graphics APIs, there is a degree of customizability provided viasetGraphicsConfiguration()
. This makes it possible, for example, to specify the list of Vulkan extensions to enable on theVkDevice
. Alternatively, it is also possible to provide a set of existing context or device objects for use by theQQuickWindow
, instead of letting it construct its own. This is achieved throughsetGraphicsDevice()
.- class CreateTextureOption¶
(inherits
enum.Flag
) The CreateTextureOption enums are used to customize a texture is wrapped.Constant
Description
QQuickWindow.TextureHasAlphaChannel
The texture has an alpha channel and should be drawn using blending.
QQuickWindow.TextureHasMipmaps
The texture has mipmaps and can be drawn with mipmapping enabled.
QQuickWindow.TextureOwnsGLTexture
As of Qt 6.0, this flag is not used in practice and is ignored. Native graphics resource ownership is not transferable to the wrapping
QSGTexture
, because Qt Quick may not have the necessary details on how such an object and the associated memory should be freed.QQuickWindow.TextureCanUseAtlas
The image can be uploaded into a texture atlas.
QQuickWindow.TextureIsOpaque
The texture will return false for
hasAlphaChannel()
and will not be blended. This flag was added in Qt 5.6.
- class RenderStage¶
Constant
Description
QQuickWindow.BeforeSynchronizingStage
Before synchronization.
QQuickWindow.AfterSynchronizingStage
After synchronization.
QQuickWindow.BeforeRenderingStage
Before rendering.
QQuickWindow.AfterRenderingStage
After rendering.
QQuickWindow.AfterSwapStage
After the frame is swapped.
QQuickWindow.NoStage
As soon as possible. This value was added in Qt 5.6.
See also
Scene Graph and Rendering
- class SceneGraphError¶
This enum describes the error in a
sceneGraphError()
signal.Constant
Description
QQuickWindow.ContextNotAvailable
graphics context creation failed. This typically means that no suitable OpenGL implementation was found, for example because no graphics drivers are installed and so no OpenGL 2 support is present. On mobile and embedded boards that use OpenGL ES such an error is likely to indicate issues in the windowing system integration and possibly an incorrect configuration of Qt.
- class TextRenderType¶
This enum describes the default render type of text-like elements in Qt Quick ( Text , TextInput , etc.).
Select NativeTextRendering if you prefer text to look native on the target platform and do not require advanced features such as transformation of the text. Using such features in combination with the NativeTextRendering render type will lend poor and sometimes pixelated results.
Both
QtTextRendering
andCurveTextRendering
are hardware-accelerated techniques.QtTextRendering
is the faster of the two, but uses more memory and will exhibit rendering artifacts at large sizes.CurveTextRendering
should be considered as an alternative in cases whereQtTextRendering
does not give good visual results or where reducing graphics memory consumption is a priority.Constant
Description
QQuickWindow.QtTextRendering
Use Qt’s own rasterization algorithm.
QQuickWindow.NativeTextRendering
Use the operating system’s native rasterizer for text.
QQuickWindow.CurveTextRendering
Text is rendered using a curve rasterizer running directly on the graphics hardware. (Introduced in Qt 6.7.0.)
Note
Properties can be used directly when
from __feature__ import true_property
is used or via accessor functions otherwise.- property activeFocusItemᅟ: QQuickItem¶
This property holds The item which currently has active focus or
null
if there is no item with active focus..See also
forceActiveFocus()
Keyboard Focus in Qt Quick- Access functions:
This property holds The color used to clear the color buffer at the beginning of each frame..
By default, the clear color is white.
See also
- Access functions:
Signal
colorChanged()
- property contentItemᅟ: QQuickItem¶
This property holds The invisible root item of the scene..
A
QQuickWindow
always has a single invisible root item containing all of its content. To add items to this window, reparent the items to the contentItem or to an existing item in the scene.- Access functions:
- __init__(renderControl)¶
- Parameters:
renderControl –
QQuickRenderControl
Constructs a window for displaying a QML scene, whose rendering will be controlled by the
control
object. Please refer toQQuickRenderControl
‘s documentation for more information.- __init__([parent=None])
- Parameters:
parent –
QWindow
Constructs a window for displaying a QML scene with parent window
parent
.- activeFocusItem()¶
- Return type:
Getter of property
activeFocusItemᅟ
.- activeFocusItemChanged()¶
Notification signal of property
activeFocusItemᅟ
.- afterAnimating()¶
This signal is emitted on the GUI thread before requesting the render thread to perform the synchronization of the scene graph.
Unlike the other similar signals, this one is emitted on the GUI thread instead of the render thread. It can be used to synchronize external animation systems with the QML content. At the same time this means that this signal is not suitable for triggering graphics operations.
- afterFrameEnd()¶
This signal is emitted when the scene graph has submitted a frame. This is emitted after all other related signals, such as
afterRendering()
. It is the last signal that is emitted by the scene graph rendering thread when rendering a frame.Note
Unlike
frameSwapped()
, this signal is guaranteed to be emitted also when the Qt Quick output is redirected viaQQuickRenderControl
.Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
See also
- afterRenderPassRecording()¶
This signal is emitted after the scenegraph has recorded the commands for its main render pass, but the pass is not yet finalized on the command buffer.
This signal is emitted earlier than
afterRendering()
, and it guarantees that not just the frame but also the recording of the scenegraph’s main render pass is still active. This allows inserting commands without having to generate an entire, separate render pass (which would typically clear the attached images). The native graphics objects can be queried viaQSGRendererInterface
.Note
Resource updates (uploads, copies) typically cannot be enqueued from within a render pass. Therefore, more complex user rendering will need to connect to both
beforeRendering()
and this signal.Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
See also
rendererInterface()
Scene Graph - RHI Under QML- afterRendering()¶
The signal is emitted after scene graph has added its commands to the command buffer, which is not yet submitted to the graphics queue. If desired, the slot function connected to this signal can query native resources, like the command buffer, before via
QSGRendererInterface
. Note however that the render pass (or passes) are already recorded at this point and it is not possible to add more commands within the scenegraph’s pass. Instead, useafterRenderPassRecording()
for that. This signal has therefore limited use in Qt 6, unlike in Qt 5. Rather, it is the combination ofbeforeRendering()
andbeforeRenderPassRecording()
, orbeforeRendering()
andafterRenderPassRecording()
, that is typically used to achieve under- or overlaying of the custom rendering.Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
Note
When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific states and leaving these enabled or set to non-default values when returning from the connected slot can interfere with the scene graph’s rendering. The QOpenGLContext used for rendering by the scene graph will be bound when the signal is emitted.
See also
rendererInterface()
Scene Graph - RHI Under QML Scene Graph - OpenGL Under QML Scene Graph - Metal Under QML Scene Graph - Vulkan Under QML Scene Graph - Direct3D 11 Under QML- afterSynchronizing()¶
This signal is emitted after the scene graph is synchronized with the QML state.
This signal can be used to do preparation required after calls to
updatePaintNode()
, while the GUI thread is still locked.When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.
Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
Warning
When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific states and leaving these enabled or set to non-default values when returning from the connected slot can interfere with the scene graph’s rendering.
- beforeFrameBegin()¶
This signal is emitted before the scene graph starts preparing the frame. This precedes signals like
beforeSynchronizing()
orbeforeRendering()
. It is the earliest signal that is emitted by the scene graph rendering thread when starting to prepare a new frame.This signal is relevant for lower level graphics frameworks that need to execute certain operations, such as resource cleanup, at a stage where Qt Quick has not initiated the recording of a new frame via the underlying rendering hardware interface APIs.
Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
See also
- beforeRenderPassRecording()¶
This signal is emitted before the scenegraph starts recording commands for the main render pass. (Layers have their own passes and are fully recorded by the time this signal is emitted.) The render pass is already active on the command buffer when the signal is emitted.
This signal is emitted later than
beforeRendering()
and it guarantees that not just the frame, but also the recording of the scenegraph’s main render pass is active. This allows inserting commands without having to generate an entire, separate render pass (which would typically clear the attached images). The native graphics objects can be queried viaQSGRendererInterface
.Note
Resource updates (uploads, copies) typically cannot be enqueued from within a render pass. Therefore, more complex user rendering will need to connect to both
beforeRendering()
and this signal.Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
See also
rendererInterface()
Scene Graph - RHI Under QML- beforeRendering()¶
This signal is emitted after the preparations for the frame have been done, meaning there is a command buffer in recording mode, where applicable. If desired, the slot function connected to this signal can query native resources like the command before via
QSGRendererInterface
. Note however that the recording of the main render pass is not yet started at this point and it is not possible to add commands within that pass. Starting a pass means clearing the color, depth, and stencil buffers so it is not possible to achieve an underlay type of rendering by just connecting to this signal. Rather, connect tobeforeRenderPassRecording()
. However, connecting to this signal is still important if the recording of copy type of commands is desired since those cannot be enqueued within a render pass.Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
Note
When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific states and leaving these enabled or set to non-default values when returning from the connected slot can interfere with the scene graph’s rendering. The QOpenGLContext used for rendering by the scene graph will be bound when the signal is emitted.
See also
rendererInterface()
Scene Graph - RHI Under QML Scene Graph - OpenGL Under QML Scene Graph - Metal Under QML Scene Graph - Vulkan Under QML Scene Graph - Direct3D 11 Under QML- beforeSynchronizing()¶
This signal is emitted before the scene graph is synchronized with the QML state.
Even though the signal is emitted from the scene graph rendering thread, the GUI thread is guaranteed to be blocked, like it is in
updatePaintNode()
. Therefore, it is safe to access GUI thread thread data in a slot or lambda that is connected with Qt::DirectConnection.This signal can be used to do any preparation required before calls to
updatePaintNode()
.When using OpenGL, the QOpenGLContext used for rendering by the scene graph will be bound at this point.
Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
Warning
When using OpenGL, be aware that setting OpenGL 3.x or 4.x specific states and leaving these enabled or set to non-default values when returning from the connected slot can interfere with the scene graph’s rendering.
- beginExternalCommands()¶
When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene graph rendering, it is necessary to call this function before recording commands to the command buffer used by the scene graph to render its main render pass. This is to avoid clobbering state.
In practice this function is often called from a slot connected to the
beforeRenderPassRecording()
orafterRenderPassRecording()
signals.The function does not need to be called when recording commands to the application’s own command buffer (such as, a VkCommandBuffer or MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the application, not retrieved from the scene graph). With graphics APIs where no native command buffer concept is exposed (OpenGL, Direct 3D 11), beginExternalCommands() and
endExternalCommands()
together provide a replacement for the Qt 5 resetOpenGLState() function.Calling this function and
endExternalCommands()
is not necessary within therender()
implementation of aQSGRenderNode
because the scene graph performs the necessary steps implicitly for render nodes.Native graphics objects (such as, graphics device, command buffer or encoder) are accessible via
getResource()
.Warning
Watch out for the fact that
CommandListResource
may return a different object between beginExternalCommands() -endExternalCommands()
. This can happen when the underlying implementation provides a dedicated secondary command buffer for recording external graphics commands within a render pass. Therefore, always query CommandListResource after calling this function. Do not attempt to reuse an object from an earlier query.Note
When the scenegraph is using OpenGL, pay attention to the fact that the OpenGL state in the context can have arbitrary settings, and this function does not perform any resetting of the state back to defaults.
See also
endExternalCommands()
resetOpenGLState()
- color()¶
- Return type:
See also
Getter of property
colorᅟ
.Notification signal of property
colorᅟ
.- contentItem()¶
- Return type:
Getter of property
contentItemᅟ
.- createImageNode()¶
- Return type:
Creates a simple image node. When the scenegraph is not initialized, the return value is null.
This is cross-backend alternative to constructing a
QSGSimpleTextureNode
directly.See also
- createNinePatchNode()¶
- Return type:
Creates a nine patch node. When the scenegraph is not initialized, the return value is null.
- createRectangleNode()¶
- Return type:
Creates a simple rectangle node. When the scenegraph is not initialized, the return value is null.
This is cross-backend alternative to constructing a
QSGSimpleRectNode
directly.See also
- createTextNode()¶
- Return type:
Creates a text node. When the scenegraph is not initialized, the return value is null.
See also
This is an overloaded function.
- createTextureFromImage(image, options)
- Parameters:
image –
QImage
options – Combination of
CreateTextureOption
- Return type:
Creates a new
QSGTexture
from the suppliedimage
. If the image has an alpha channel, the corresponding texture will have an alpha channel.The caller of the function is responsible for deleting the returned texture. The underlying native texture object is then destroyed together with the
QSGTexture
.When
options
containsTextureCanUseAtlas
, the engine may put the image into a texture atlas. Textures in an atlas need to rely onnormalizedTextureSubRect()
for their geometry and will not supportRepeat
. Other values fromCreateTextureOption
are ignored.When
options
containsTextureIsOpaque
, the engine will create an RGB texture which returns false forhasAlphaChannel()
. Opaque textures will in most cases be faster to render. When this flag is not set, the texture will have an alpha channel based on the image’s format.When
options
containsTextureHasMipmaps
, the engine will create a texture which can use mipmap filtering. Mipmapped textures can not be in an atlas.Setting
TextureHasAlphaChannel
inoptions
serves no purpose for this function since assuming an alpha channel and blending is the default. To opt out, setTextureIsOpaque
.When the scene graph uses OpenGL, the returned texture will be using
GL_TEXTURE_2D
as texture target andGL_RGBA
as internal format. With other graphics APIs, the texture format is typicallyRGBA8
. ReimplementQSGTexture
to create textures with different parameters.Warning
This function will return 0 if the scene graph has not yet been initialized.
Warning
The returned texture is not memory managed by the scene graph and must be explicitly deleted by the caller on the rendering thread. This is achieved by deleting the texture from a
QSGNode
destructor or by using deleteLater() in the case where the texture already has affinity to the rendering thread.This function can be called from both the main and the render thread.
See also
- createTextureFromRhiTexture(texture[, options={}])¶
- Parameters:
texture –
QRhiTexture
options – Combination of
CreateTextureOption
- Return type:
Creates a new
QSGTexture
from the suppliedtexture
.Use
options
to customize the texture attributes. Only theTextureHasAlphaChannel
flag is taken into account by this function. When set, the resultingQSGTexture
is always treated by the scene graph renderer as needing blending. For textures that are fully opaque, not setting the flag can save the cost of performing alpha blending during rendering. The flag has no direct correspondence to the format of the QRhiTexture, i.e. not setting the flag while having a texture format such as the commonly used QRhiTexture::RGBA8 is perfectly normal.Mipmapping is not controlled by
options
sincetexture
is already created and has the presence or lack of mipmaps baked in.The returned
QSGTexture
owns the QRhiTexture, meaningtexture
is destroyed together with the returnedQSGTexture
.If
texture
owns its underlying native graphics resources (OpenGL texture object, Vulkan image, etc.), that depends on how the QRhiTexture was created (QRhiTexture::create() or QRhiTexture::createFrom()), and that is not controlled or changed by this function.Note
This is only functional when the scene graph has already initialized and is using the default, QRhi-based adaptation . The return value is
None
otherwise.Note
This function can only be called on the scene graph render thread.
- effectiveDevicePixelRatio()¶
- Return type:
float
Returns the device pixel ratio for this window.
This is different from QWindow::devicePixelRatio() in that it supports redirected rendering via
QQuickRenderControl
andQQuickRenderTarget
. When using aQQuickRenderControl
, theQQuickWindow
is often not fully created, meaning it is never shown and there is no underlying native window created in the windowing system. As a result, querying properties like the device pixel ratio cannot give correct results. This function takes into account bothrenderWindowFor()
anddevicePixelRatio()
. When no redirection is in effect, the result is same as QWindow::devicePixelRatio().- endExternalCommands()¶
When mixing raw graphics (OpenGL, Vulkan, Metal, etc.) commands with scene graph rendering, it is necessary to call this function after recording commands to the command buffer used by the scene graph to render its main render pass. This is to avoid clobbering state.
In practice this function is often called from a slot connected to the
beforeRenderPassRecording()
orafterRenderPassRecording()
signals.The function does not need to be called when recording commands to the application’s own command buffer (such as, a VkCommandBuffer or MTLCommandBuffer + MTLRenderCommandEncoder created and managed by the application, not retrieved from the scene graph). With graphics APIs where no native command buffer concept is exposed (OpenGL, Direct 3D 11),
beginExternalCommands()
and endExternalCommands() together provide a replacement for the Qt 5 resetOpenGLState() function.Calling this function and
beginExternalCommands()
is not necessary within therender()
implementation of aQSGRenderNode
because the scene graph performs the necessary steps implicitly for render nodes.See also
beginExternalCommands()
resetOpenGLState()
- frameSwapped()¶
This signal is emitted when a frame has been queued for presenting. With vertical synchronization enabled the signal is emitted at most once per vsync interval in a continuously animating scene.
This signal will be emitted from the scene graph rendering thread.
Grabs the contents of the window and returns it as an image.
It is possible to call the grabWindow() function when the window is not visible. This requires that the window is created and has a valid size and that no other
QQuickWindow
instances are rendering in the same process.Note
When using this window in combination with
QQuickRenderControl
, the result of this function is an empty image, unless thesoftware
backend is in use. This is because when redirecting the output to an application-managed graphics resource (such as, a texture) by usingQQuickRenderControl
andsetRenderTarget()
, the application is better suited for managing and executing an eventual read back operation, since it is in full control of the resource to begin with.Warning
Calling this function will cause performance problems.
Warning
This function can only be called from the GUI thread.
- static graphicsApi()¶
- Return type:
Returns the graphics API that would be used by the scene graph if it was initialized at this point in time.
The standard way to query the API used by the scene graph is to use
graphicsApi()
once the scene graph has initialized, for example when or after thesceneGraphInitialized()
signal is emitted. In that case one gets the true, real result, because then it is known that everything was initialized correctly using that graphics API.This is not always convenient. If the application needs to set up external frameworks, or needs to work with
setGraphicsDevice()
in a manner that depends on the scene graph’s built in API selection logic, it is not always feasiable to defer such operations until after theQQuickWindow
has been made visible orinitialize()
has been called.Therefore, this static function is provided as a counterpart to
setGraphicsApi()
: it can be called at any time, and the result reflects what API the scene graph would choose if it was initialized at the point of the call.Note
This static function is intended to be called on the main (GUI) thread only. For querying the API when rendering, use
QSGRendererInterface
since that object lives on the render thread.- graphicsConfiguration()¶
- Return type:
Returns the
QQuickGraphicsDevice
passed tosetGraphicsDevice()
, or a default constructed one otherwiseSee also
- graphicsDevice()¶
- Return type:
Returns the
QQuickGraphicsDevice
passed tosetGraphicsDevice()
, or a default constructed one otherwiseSee also
- graphicsStateInfo()¶
- Return type:
GraphicsStateInfo
Returns a reference to a
GraphicsStateInfo
struct describing some of the RHI’s internal state, in particular, the double or tripple buffering status of the backend (such as, the Vulkan or Metal integrations). This is relevant when the underlying graphics APIs is Vulkan or Metal, and the external rendering code wishes to perform double or tripple buffering of its own often-changing resources, such as, uniform buffers, in order to avoid stalling the pipeline.- static hasDefaultAlphaBuffer()¶
- Return type:
bool
Returns whether to use alpha transparency on newly created windows.
See also
- incubationController()¶
- Return type:
Returns an incubation controller that splices incubation between frames for this window.
QQuickView
automatically installs this controller for you, otherwise you will need to install it yourself using QQmlEngine::setIncubationController().The controller is owned by the window and will be destroyed when the window is deleted.
- isPersistentGraphics()¶
- Return type:
bool
Returns whether essential graphics resources can be released during the lifetime of the
QQuickWindow
.Note
This is a hint, and is not guaranteed that it is taken into account.
See also
- isPersistentSceneGraph()¶
- Return type:
bool
Returns whether the scene graph nodes and resources can be released during the lifetime of this
QQuickWindow
.Note
This is a hint. When and how this happens is implementation specific.
- isSceneGraphInitialized()¶
- Return type:
bool
Returns true if the scene graph has been initialized; otherwise returns false.
- mouseGrabberItem()¶
- Return type:
Use QPointerEvent::exclusiveGrabber(). Returns the item which currently has the mouse grab.
- paletteChanged()¶
- paletteCreated()¶
- releaseResources()¶
This function tries to release redundant resources currently held by the QML scene.
Calling this function requests the scene graph to release cached graphics resources, such as graphics pipeline objects, shader programs, or image data.
Additionally, depending on the render loop in use, this function may also result in the scene graph and all window-related rendering resources to be released. If this happens, the
sceneGraphInvalidated()
signal will be emitted, allowing users to clean up their own graphics resources. ThesetPersistentGraphics()
andsetPersistentSceneGraph()
functions can be used to prevent this from happening, if handling the cleanup is not feasible in the application, at the cost of higher memory usage.Note
The releasing of cached graphics resources, such as graphics pipelines or shader programs is not dependent on the persistency hints. The releasing of those will happen regardless of the values of the persistent graphics and scenegraph hints.
Note
This function is not related to the
releaseResources()
virtual function.- renderTarget()¶
- Return type:
Returns the
QQuickRenderTarget
passed tosetRenderTarget()
, or a default constructed one otherwiseSee also
- rendererInterface()¶
- Return type:
Returns the current renderer interface. The value is always valid and is never null.
Note
This function can be called at any time after constructing the
QQuickWindow
, even whileisSceneGraphInitialized()
is still false. However, some renderer interface functions, in particulargetResource()
will not be functional until the scenegraph is up and running. Backend queries, likegraphicsApi()
orshaderType()
, will always be functional on the other hand.Note
The ownership of the returned pointer stays with Qt. The returned instance may or may not be shared between different
QQuickWindow
instances, depending on the scenegraph backend in use. Therefore applications are expected to query the interface object for eachQQuickWindow
instead of reusing the already queried pointer.See also
- rhi()¶
- Return type:
QRhi
Returns the QRhi object used by this window for rendering.
Available only when the window is using Qt’s 3D API and shading language abstractions, meaning the result is always null when using the
software
adaptation.The result is valid only when rendering has been initialized, which is indicated by the emission of the
sceneGraphInitialized()
signal. Before that point, the returned value is null. With a regular, on-screenQQuickWindow
scenegraph initialization typically happens when the native window gets exposed (shown) the first time. When usingQQuickRenderControl
, initialization is done in the explicitinitialize()
call.In practice this function is a shortcut to querying the QRhi via the
QSGRendererInterface
.- sceneGraphAboutToStop()¶
This signal is emitted on the render thread when the scene graph is about to stop rendering. This happens usually because the window has been hidden.
Applications may use this signal to release resources, but should be prepared to reinstantiated them again fast. The scene graph and the graphics context are not released at this time.
Warning
This signal is emitted from the scene graph rendering thread. If your slot function needs to finish before execution continues, you must make sure that the connection is direct (see Qt::ConnectionType).
Warning
Make very sure that a signal handler for sceneGraphAboutToStop() leaves the graphics context in the same state as it was when the signal handler was entered. Failing to do so can result in the scene not rendering properly.
See also
- static sceneGraphBackend()¶
- Return type:
str
Returns the requested Qt Quick scenegraph backend.
Note
The return value of this function may still be outdated by subsequent calls to
setSceneGraphBackend()
until the firstQQuickWindow
in the application has been constructed.Note
The value only reflects the request in the
QT_QUICK_BACKEND
environment variable after aQQuickWindow
has been constructed.See also
- sceneGraphError(error, message)¶
- Parameters:
error –
SceneGraphError
message – str
This signal is emitted when an
error
occurred during scene graph initialization.Applications should connect to this signal if they wish to handle errors, like graphics context creation failures, in a custom way. When no slot is connected to the signal, the behavior will be different: Quick will print the
message
, or show a message box, and terminate the application.This signal will be emitted from the GUI thread.
- sceneGraphInitialized()¶
This signal is emitted when the scene graph has been initialized.
This signal will be emitted from the scene graph rendering thread.
- sceneGraphInvalidated()¶
This signal is emitted when the scene graph has been invalidated.
This signal implies that the graphics rendering context used has been invalidated and all user resources tied to that context should be released.
When rendering with OpenGL, the QOpenGLContext of this window will be bound when this function is called. The only exception is if the native OpenGL has been destroyed outside Qt’s control, for instance through EGL_CONTEXT_LOST.
This signal will be emitted from the scene graph rendering thread.
- scheduleRenderJob(job, schedule)¶
- Parameters:
job –
QRunnable
schedule –
RenderStage
Schedules
job
to run when the rendering of this window reaches the givenstage
.This is a convenience to the equivalent signals in
QQuickWindow
for “one shot” tasks.The window takes ownership over
job
and will delete it when the job is completed.If rendering is shut down before
job
has a chance to run, the job will be run and then deleted as part of the scene graph cleanup. If the window is never shown and no rendering happens before theQQuickWindow
is destroyed, all pending jobs will be destroyed without their run() method being called.If the rendering is happening on a different thread, then the job will happen on the rendering thread.
If
stage
isNoStage
,job
will be run at the earliest opportunity whenever the render thread is not busy rendering a frame. If the window is not exposed, and is not renderable, at the time the job is either posted or handled, the job is deleted without executing the run() method. If a non-threaded renderer is in use, the run() method of the job is executed synchronously. When rendering with OpenGL, the OpenGL context is changed to the renderer’s context before executing any job, includingNoStage
jobs.Note
This function does not trigger rendering; the jobs targeting any other stage than
NoStage
will be stored run until rendering is triggered elsewhere. To force the job to run earlier, callupdate()
;Setter of property
colorᅟ
.- static setDefaultAlphaBuffer(useAlpha)¶
- Parameters:
useAlpha – bool
useAlpha
specifies whether to use alpha transparency on newly created windows.In any application which expects to create translucent windows, it’s necessary to set this to true before creating the first
QQuickWindow
. The default value is false.See also
- static setGraphicsApi(api)¶
- Parameters:
api –
GraphicsApi
Requests the specified graphics
api
.When the built-in, default graphics adaptation is used,
api
specifies which graphics API (OpenGL, Vulkan, Metal, or Direct3D) the scene graph should use to render. In addition, thesoftware
backend is built-in as well, and can be requested by settingapi
toSoftware
.Unlike
setSceneGraphBackend()
, which can only be used to request a given backend (shipped either built-in or installed as dynamically loaded plugins), this function works with the higher level concept of graphics APIs. It covers the backends that ship with Qt Quick, and thus have corresponding values in theGraphicsApi
enum.When this function is not called at all, and the equivalent environment variable
QSG_RHI_BACKEND
is not set either, the scene graph will choose the graphics API to use based on the platform.This function becomes important in applications that are only prepared for rendering with a given API. For example, if there is native OpenGL or Vulkan rendering done by the application, it will want to ensure Qt Quick is rendering using OpenGL or Vulkan too. Such applications are expected to call this function early in their main() function.
Note
The call to the function must happen before constructing the first
QQuickWindow
in the application. The graphics API cannot be changed afterwards.Note
When used in combination with
QQuickRenderControl
, this rule is relaxed: it is possible to change the graphics API, but only when all existingQQuickRenderControl
andQQuickWindow
instances have been destroyed.To query what graphics API the scene graph is using to render,
graphicsApi()
after the scene graphhas initialized
, which typically happens either when the window becomes visible for the first time, or wheninitialize()
is called.To switch back to the default behavior, where the scene graph chooses a graphics API based on the platform and other conditions, set
api
toUnknown
.See also
- setGraphicsConfiguration(config)¶
- Parameters:
config –
QQuickGraphicsConfiguration
Sets the graphics configuration for this window.
config
contains various settings that may be taken into account by the scene graph when initializing the underlying graphics devices and contexts.Such additional configuration, specifying for example what device extensions to enable for Vulkan, becomes relevant and essential when integrating native graphics rendering code that relies on certain extensions. The same is true when integrating with an external 3D or VR engines, such as OpenXR.
Note
The configuration is ignored when adopting existing graphics devices via
setGraphicsDevice()
since the scene graph is then not in control of the actual construction of those objects.QQuickGraphicsConfiguration
instances are implicitly shared, copyable, and can be passed by value.Warning
Setting a
QQuickGraphicsConfiguration
on aQQuickWindow
must happen early enough, before the scene graph is initialized for the first time for that window. With on-screen windows this means the call must be done before invoking show() on theQQuickWindow
orQQuickView
. WithQQuickRenderControl
the configuration must be finalized before callinginitialize()
.See also
- setGraphicsDevice(device)¶
- Parameters:
device –
QQuickGraphicsDevice
Sets the graphics device objects for this window. The scenegraph will use existing device, physical device, and other objects specified by
device
instead of creating new ones.This function is very often used in combination with
QQuickRenderControl
andsetRenderTarget()
, in order to redirect Qt Quick rendering into a texture.A default constructed
QQuickGraphicsDevice
does not change the default behavior in any way. Once adevice
created via one of theQQuickGraphicsDevice
factory functions, such as,fromDeviceObjects()
, is passed in, and the scenegraph uses a matching graphics API (with the example of fromDeviceObjects(), that would be Vulkan), the scenegraph will use the existing device objects (such as, theVkPhysicalDevice
,VkDevice
, and graphics queue family index, in case of Vulkan) encapsulated by theQQuickGraphicsDevice
. This allows using the same device, and so sharing resources, such as buffers and textures, between Qt Quick and native rendering engines.Warning
This function can only be called before initializing the scenegraph and will have no effect if called afterwards. In practice this typically means calling it right before
initialize()
.As an example, this time with Direct3D, the typical usage is expected to be the following:
// native graphics resources set up by a custom D3D rendering engine ID3D11Device *device; ID3D11DeviceContext *context; ID3D11Texture2D *texture; ... // now to redirect Qt Quick content into 'texture' we could do the following: QQuickRenderControl *renderControl = new QQuickRenderControl; QQuickWindow *window = new QQuickWindow(renderControl); // this window will never be shown on-screen ... window->setGraphicsDevice(QQuickGraphicsDevice::fromDeviceAndContext(device, context)); renderControl->initialize(); window->setRenderTarget(QQuickRenderTarget::fromD3D11Texture(texture, textureSize); ...
The key aspect of using this function is to ensure that resources or handles to resources, such as
texture
in the above example, are visible to and usable by both the external rendering engine and the scenegraph renderer. This requires using the same graphics device (or with OpenGL, OpenGL context).QQuickGraphicsDevice
instances are implicitly shared, copyable, and can be passed by value. They do not own the associated native objects (such as, the ID3D11Device in the example).Note
Using
QQuickRenderControl
does not always imply having to call this function. When adopting an existing device or context is not needed, this function should not be called, and the scene graph will then initialize its own devices and contexts normally, just as it would with an on-screenQQuickWindow
.- setPersistentGraphics(persistent)¶
- Parameters:
persistent – bool
Sets whether the graphics resources (graphics device or context, swapchain, buffers, textures) should be preserved, and cannot be released until the last window is deleted, to
persistent
. The default value is true.When calling
releaseResources()
, or when the window gets hidden (more specifically, not renderable), some render loops have the possibility to release all, not just the cached, graphics resources. This can free up memory temporarily, but it also means the rendering engine will have to do a full, potentially costly reinitialization of the resources when the window needs to render again.Note
The rules for when a window is not renderable are platform and window manager specific.
Note
All graphics resources are released when the last
QQuickWindow
is deleted, regardless of this setting.Note
This is a hint, and is not guaranteed that it is taken into account.
Note
This hint does not apply to cached resources, that are relatively cheap to drop and then recreate later. Therefore, calling
releaseResources()
will typically lead to releasing those regardless of the value of this hint.- setPersistentSceneGraph(persistent)¶
- Parameters:
persistent – bool
Sets whether the scene graph nodes and resources are
persistent
. Persistent means the nodes and resources cannot be released. The default value istrue
.When calling
releaseResources()
, when the window gets hidden (more specifically, not renderable), some render loops have the possibility to release the scene graph nodes and related graphics resources. This frees up memory temporarily, but will also mean the scene graph has to be rebuilt when the window renders next time.Note
The rules for when a window is not renderable are platform and window manager specific.
Note
The scene graph nodes and resources are always released when the last
QQuickWindow
is deleted, regardless of this setting.Note
This is a hint, and is not guaranteed that it is taken into account.
- setRenderTarget(target)¶
- Parameters:
target –
QQuickRenderTarget
Sets the render target for this window to be
target
.A
QQuickRenderTarget
serves as an opaque handle for a renderable native object, most commonly a 2D texture, and associated metadata, such as the size in pixels.A default constructed
QQuickRenderTarget
means no redirection. A validtarget
, created via one of the staticQQuickRenderTarget
factory functions, on the other hand, enables redirection of the rendering of the Qt Quick scene: it will no longer target the color buffers for the surface associated with the window, but rather the textures or other graphics objects specified intarget
.For example, assuming the scenegraph is using Vulkan to render, one can redirect its output into a
VkImage
. For graphics APIs like Vulkan, the image layout must be provided as well.QQuickRenderTarget
instances are implicitly shared and are copyable and can be passed by value. They do not own the associated native objects (such as, the VkImage in the example), however.QQuickRenderTarget rt = QQuickRenderTarget::fromVulkanImage(vulkanImage, VK_IMAGE_LAYOUT_PREINITIALIZED, pixelSize); quickWindow->setRenderTarget(rt);
This function is very often used in combination with
QQuickRenderControl
and an invisibleQQuickWindow
, in order to render Qt Quick content into a texture, without creating an on-screen native window for thisQQuickWindow
.When the desired target, or associated data, such as the size, changes, call this function with a new
QQuickRenderTarget
. ConstructingQQuickRenderTarget
instances and calling this function is cheap, but be aware that setting a newtarget
with a different native object or other data may lead to potentially expensive initialization steps when the scenegraph is about to render the next frame. Therefore change the target only when necessary.Note
The window does not take ownership of any native objects referenced in
target
.Note
It is the caller’s responsibility to ensure the native objects referred to in
target
are valid for the scenegraph renderer too. For instance, with Vulkan, Metal, and Direct3D this implies that the texture or image is created on the same graphics device that is used by the scenegraph internally. Therefore, when texture objects created on an already existing device or context are involved, this function is often used in combination withsetGraphicsDevice()
.Note
With graphics APIs where relevant, the application must pay attention to image layout transitions performed by the scenegraph. For example, once a VkImage is associated with the scenegraph by calling this function, its layout will transition to
VK_IMAGE_LAYOUT_COLOR_ATTACHMENT_OPTIMAL
when rendering a frame.Warning
This function can only be called from the thread doing the rendering.
- static setSceneGraphBackend(backend)¶
- Parameters:
backend – str
Requests a Qt Quick scenegraph
backend
. Backends can either be built-in or be installed in form of dynamically loaded plugins.This is an overloaded function.
Note
The call to the function must happen before constructing the first
QQuickWindow
in the application. It cannot be changed afterwards.See Switch Between Adaptations in Your Application for more information about the list of backends. If
backend
is invalid or an error occurs, the request is ignored.Note
Calling this function is equivalent to setting the
QT_QUICK_BACKEND
orQMLSCENE_DEVICE
environment variables. However, this API is safer to use in applications that spawn other processes as there is no need to worry about environment inheritance.See also
- static setTextRenderType(renderType)¶
- Parameters:
renderType –
TextRenderType
Sets the default render type of text-like elements in Qt Quick to
renderType
.Note
setting the render type will only affect elements created afterwards; the render type of existing elements will not be modified.
See also
- swapChain()¶
- Return type:
QRhiSwapChain
Returns the QRhiSwapChain used by this window, if there is one.
Note
Only on-screen windows backed by one of the standard render loops (such as,
basic
orthreaded
) will have a swapchain. Otherwise the returned value is null. For example, the result is always null when the window is used withQQuickRenderControl
.- static textRenderType()¶
- Return type:
Returns the render type of text-like elements in Qt Quick. The default is
QtTextRendering
.See also
- update()¶
Schedules the window to render another frame.
Calling QQuickWindow::update() differs from
update()
in that it always triggers a repaint, regardless of changes in the underlying scene graph or not.