QCanvasRhiPaintDriver Class
La classe `QCanvasRhiPaintDriver` gère les aspects de bas niveau du rendu basé sur l'QCanvasPainter pour les cibles de rendu de type « QRhi » et les canevas hors écran. En savoir plus...
| En-tête : | #include <QCanvasRhiPaintDriver> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS CanvasPainter) target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter) |
| Depuis : | Qt 6.11 |
Types publics
| enum class | BeginPaintFlag { DepthTest } |
| flags | BeginPaintFlags |
| enum class | EndPaintFlag { DoNotRecordRenderPass } |
| flags | EndPaintFlags |
Fonctions publiques
| void | beginPaint(QCanvasOffscreenCanvas &canvas, QRhiCommandBuffer *cb, QCanvasRhiPaintDriver::BeginPaintFlags flags = {}) |
| void | beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, const QMatrix4x4 &matrix, QCanvasRhiPaintDriver::BeginPaintFlags flags = {}) |
| void | beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, QColor fillColor = Qt::black, QSize logicalSize = QSize(), qreal dpr = 1.0, QCanvasRhiPaintDriver::BeginPaintFlags flags = {}) |
| void | endPaint(QCanvasRhiPaintDriver::EndPaintFlags flags = {}) |
| void | grabCanvas(const QCanvasOffscreenCanvas &canvas, const QObject *context, Functor &&callback) |
| void | renderPaint() |
| void | resetForNewFrame() |
Description détaillée
Les applications souhaitant effectuer un rendu à l’aide d’ QCanvasPainter sur une cible de rendu basée sur QRhi, telle qu’un QRhiTexture, ou sur le tampon de couleur d’un QRhiSwapChain, utilisent QCanvasPainterFactory pour initialiser et récupérer un QCanvasPainter et un QCanvasRhiPaintDriver associés à l’ QRhi. L'API de dessin est fournie par QCanvasPainter, tandis que les aspects de bas niveau du rendu (quelle est la cible de rendu, quel est le tampon de commandes, etc.) sont contrôlés par QCanvasRhiPaintDriver.
Remarque : cette classe n’est pertinente que lorsque l’on utilise QCanvasPainter sans classe de commodité telle que QCanvasPainterWidget ou QCanvasPainterItem, car celles-ci fournissent une instance de QCanvasPainter à l’application et gèrent son rendu de manière implicite.
Les applications ne créent pas elles-mêmes d’instances de QCanvasRhiPaintDriver. Elles la récupèrent plutôt à partir d’un initialized QCanvasPainterFactory créé avec succès en appelant paintDriver().
Voici une application console autonome presque complète qui dessine un cercle dans un QRhiTexture, lit le résultat et l'enregistre dans un fichier PNG :
int main(int argc, char *argv[])
{
QGuiApplication app(argc, argv);
// std::unique_ptr<QRhi> rhi(QRhi::create(...));
std::unique_ptr<QRhiTexture> tex(rhi->newTexture(QRhiTexture::RGBA8, QSize(1280, 720), 1,
QRhiTexture::RenderTarget | QRhiTexture::UsedAsTransferSource));
tex->create();
std::unique_ptr<QRhiRenderBuffer> ds(rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil, QSize(1280, 720)));
ds->create();
QRhiTextureRenderTargetDescription rtDesc;
rtDesc.setColorAttachments({ tex.get() });
rtDesc.setDepthStencilBuffer(ds.get());
std::unique_ptr<QRhiTextureRenderTarget> rt(rhi->newTextureRenderTarget(rtDesc));
std::unique_ptr<QRhiRenderPassDescriptor> rp(rt->newCompatibleRenderPassDescriptor());
rt->setRenderPassDescriptor(rp.get());
rt->create();
std::unique_ptr<QCanvasPainterFactory> factory(new QCanvasPainterFactory);
QCanvasPainter *painter = factory->create(rhi.get());
QCanvasRhiPaintDriver *pd = factory->paintDriver();
QRhiCommandBuffer *cb;
QRhiReadbackResult readbackResult;
rhi->beginOffscreenFrame(&cb);
pd->resetForNewFrame();
{
pd->beginPaint(cb, rt.get());
painter->beginPath();
painter->circle(640, 360, 180);
painter->setFillStyle(Qt::red);
painter->fill();
pd->endPaint();
QRhiResourceUpdateBatch *u = rhi->nextResourceUpdateBatch();
u->readBackTexture({ tex.get() }, &readbackResult);
cb->resourceUpdate(u);
}
rhi->endOffscreenFrame();
QImage image(reinterpret_cast<const uchar *>(readbackResult.data.constData()),
readbackResult.pixelSize.width(),
readbackResult.pixelSize.height(),
QImage::Format_RGBA8888);
if (rhi->isYUpInFramebuffer())
image.flip();
image.save("result.png");
return 0;
}Documentation sur les types de membres
enum class QCanvasRhiPaintDriver::BeginPaintFlag
flags QCanvasRhiPaintDriver::BeginPaintFlags
Spécifie les indicateurs pour la fonction beginPaint().
| Constante | Valeur | Description |
|---|---|---|
QCanvasRhiPaintDriver::BeginPaintFlag::DepthTest | 0x01 | Indique que le test de profondeur doit être activé lors du rendu. Normalement, la fonction ` QCanvasPainter ` n'écrit pas et ne teste pas le tampon de profondeur. S'il est nécessaire de comparer les valeurs écrites par un autre moteur de rendu, activez cet indicateur. La fonction de comparaison de profondeur utilisée est ` Less`. |
Le type `BeginPaintFlags` est un `typedef` de ` QFlags<BeginPaintFlag>`. Il stocke une combinaison OR de valeurs `BeginPaintFlag`.
enum class QCanvasRhiPaintDriver::EndPaintFlag
flags QCanvasRhiPaintDriver::EndPaintFlags
Spécifie les indicateurs pour la fonction ` endPaint()`.
| Constante | Valeur | Description |
|---|---|---|
QCanvasRhiPaintDriver::EndPaintFlag::DoNotRecordRenderPass | 0x01 | Indique que la vidange des commandes générées par l'QCanvasPainter et l'enregistrement du passage de rendu de l'QRhi ne sont pas souhaités, car un appel explicite à renderPaint() sera effectué par la suite. |
Le type EndPaintFlags est un typedef de QFlags<EndPaintFlag>. Il stocke une combinaison OR de valeurs EndPaintFlag.
Documentation des fonctions membres
void QCanvasRhiPaintDriver::beginPaint(QCanvasOffscreenCanvas &canvas, QRhiCommandBuffer *cb, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Commence à dessiner sur l'canvas hors écran spécifiée, en enregistrant les commandes de rendu dans le tampon de commandes cb.
Remarque : un appel à ` beginPaint()` doit toujours être suivi d’un appel à ` endPaint()`. L’imbrication n’est actuellement pas prise en charge.
L'effacement s'effectue via la fonction fill color set on the canvas, sauf si l'indicateur QCanvasOffscreenCanvas::Flag::PreserveContents est activé, auquel cas il n'y a pas d'effacement et le contenu du canevas est conservé (ce qui peut avoir des implications sur les performances, en fonction de l'architecture du GPU sous-jacent).
Remarque : l’ QRhi associée doit être en cours d’enregistrement d’une image (les fonctions `QRhi::beginFrame()` ou ` QRhi::beginOffscreenFrame()` doivent avoir été appelées), mais elle ne doit pas se trouver en état d’enregistrement de passe de rendu lorsque cette fonction est appelée.
flags Spécifie les indicateurs facultatifs qui contrôlent le rendu.
Il s’agit d’une fonction surchargée.
void QCanvasRhiPaintDriver::beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, const QMatrix4x4 &matrix, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Commence à dessiner sur la cible de rendu rt, en enregistrant les commandes de rendu dans le tampon de commandes cb.
Cette surcharge prend en paramètre une matrice personnalisée matrix, qui sert à transformer les sommets. La matrice doit être adaptée au traitement de sommets dont les coordonnées sont exprimées en pixels. Un cas d’utilisation courant consiste à passer la matrice de projection modelview de Qt Quick lors de l’implémentation d’un rendu basé sur QCanvasPainter au sein d’une sous-classe de QSGRenderNode.
La taille de la fenêtre d’affichage et le rapport de pixels du périphérique sont extraits de la cible de rendu.
Cette surcharge ne prend pas de couleur de remplissage, car en pratique, elle est censée être suivie d’un appel à ` endPaint()` avec le drapeau ` EndPaintFlag::DoNotRecordRenderPass ` activé.
Remarque : la prise en charge du découpage est limitée lorsqu’une matrice personnalisée est utilisée. Les découpages rectangulaires non transformés sont pris en charge lorsque la matrice spécifie une projection orthographique sans mise à l’échelle ni rotation supplémentaires. Il est généralement recommandé d’éviter de dessiner en s’appuyant sur le découpage dans ce mode.
Remarque : une fonction beginPaint() doit toujours être suivie d’une fonction endPaint(). L’imbrication n’est actuellement pas prise en charge.
Remarque : la fonction ` rt ` doit disposer à la fois d’un tampon de couleur et d’un tampon de profondeur-stencil. S’il existe plusieurs tampons de couleur, seul le tampon de couleur correspondant au tampon 0 est écrit. La fonction ` QCanvasPainter ` nécessite la présence d’un tampon de profondeur-stencil. Actuellement, seul le stencil est utilisé ; les tests de profondeur et l’écriture sont toujours désactivés.
Remarque : l’ QRhi associé doit être en cours d’enregistrement d’une image (les fonctions `QRhi::beginFrame()` ou ` QRhi::beginOffscreenFrame()` doivent avoir été appelées), mais il ne doit pas se trouver en état d’enregistrement de passe de rendu lorsque cette fonction est appelée.
flags Spécifie les indicateurs facultatifs qui contrôlent le rendu.
Il s’agit d’une fonction surchargée.
void QCanvasRhiPaintDriver::beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, QColor fillColor = Qt::black, QSize logicalSize = QSize(), qreal dpr = 1.0, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Commence à dessiner sur la cible de rendu rt, en enregistrant les commandes de rendu dans le tampon de commandes cb.
fillColor Spécifie la couleur utilisée pour effacer le tampon de couleur. Cette valeur est ignorée lorsque les indicateurs de la fonction endPaint() contiennent EndPaintFlag::DoNotRecordRenderPass.
Remarque : un appel à ` beginPaint()` doit toujours être suivi d’un appel à ` endPaint()`. L’imbrication n’est actuellement pas prise en charge.
Remarque : la fonction ` rt ` doit disposer à la fois d’un attachement de couleur et d’un attachement de profondeur-stencil. S’il existe plusieurs attachements de couleur, seul le tampon de couleur de l’attachement 0 est écrit. L’option ` QCanvasPainter ` nécessite la présence d’un tampon de profondeur-stencil. Actuellement, seul le stencil est utilisé ; les tests de profondeur et l’écriture sont toujours désactivés.
logicalSize est facultatif. Lorsqu’il n’est pas vide, il spécifie la taille de la fenêtre d’affichage en unités logiques. dpr doit alors spécifier le facteur d’échelle (rapport de pixels du périphérique) afin que logicalSize puisse être converti en pixels en interne. En pratique, cela sera rarement nécessaire, car la taille de la cible de rendu est utilisée automatiquement par défaut.
Remarque : l’ QRhi associé doit être en cours d’enregistrement d’une image (les fonctions `QRhi::beginFrame()` ou ` QRhi::beginOffscreenFrame()` doivent avoir été appelées), mais il ne doit pas se trouver en état d’enregistrement de passe de rendu lorsque cette fonction est appelée.
flags Spécifie les indicateurs facultatifs qui contrôlent le rendu.
Il s’agit d’une fonction surchargée.
void QCanvasRhiPaintDriver::endPaint(QCanvasRhiPaintDriver::EndPaintFlags flags = {})
Vide le cache et enregistre l'ensemble du rendu « QRhi » généré par les commandes de dessin « QCanvasPainter ».
Par défaut, cette fonction enregistre un passage de rendu complet, ce qui signifie qu’elle appellera en interne les méthodes ` QRhiCommandBuffer::beginPass()` et ` QRhiCommandBuffer::endPass()`. La couleur de fond est spécifiée par l’argument `fillColor` de la méthode ` beginPaint()`, ou par la couleur de remplissage du canevas hors écran.
flags peut être utilisé pour contrôler l’enregistrement d’un passage de rendu, car dans certains cas, il n’est pas souhaitable de laisser endPaint() émettre une séquence complète beginPass() - endPass().
Les deux extraits de code suivants donnent des résultats identiques, mais le second offre davantage de flexibilité, au cas où l'application souhaiterait effectuer d'autres opérations au cours du même passage de rendu :
pd->beginPaint(cb, rt, Qt::black);
// painter->...
pd->endPaint();pd->beginPaint(cb, rt);
// painter->...
pd->endPaint(QCanvasRhiPaintDriver::EndPaintFlag::DoNotRecordRenderPass);
cb->beginPass(rt, Qt::black, { 1.0f, 0 });
pd->renderPaint();
cb->endPass();Voir également beginPaint() et renderPaint().
template <typename Functor> void QCanvasRhiPaintDriver::grabCanvas(const QCanvasOffscreenCanvas &canvas, const QObject *context, Functor &&callback)
Émet une requête de relecture de texture pour canvas, en l'associant à context.
callback est appelée soit avant que la fonction ne renvoie une valeur, soit plus tard, selon l’implémentation sous-jacente d’ QRhi et de l’API 3D. La relecture du contenu d’une texture peut impliquer une copie GPU→CPU, selon l’architecture du GPU. Elle prend un seul argument const QImage & et peut être n’importe quel foncteur, y compris ceux de type « move-only ».
Si context est détruit avant la fin de la relecture, la capture est annulée et callback n’est pas appelé. Cela permet au callback de référencer en toute sécurité des objets qui pourraient ne pas survivre à la relecture en cours.
Cette fonction peut être appelée aussi bien à l’intérieur d’un bloc beginPaint() - endPaint() qu’à l’extérieur. Lorsqu’elle est appelée à l’extérieur, elle appelle en interne QRhi::beginOffscreenFrame() etc., ce qui permet d’effectuer des captures à tout moment.
Par exemple, le code suivant enregistrerait le contenu d’un canevas hors écran dans un fichier PNG :
void QCanvasRhiPaintDriver::renderPaint()
Enregistre tous les rendus d'QRhi s générés par les commandes de dessin de l'QCanvasPainter. N'appelez cette fonction que lorsque la fonction endPaint() a été appelée avec l'argument DoNotRecordRenderPass. Elle ne doit en aucun cas être appelée dans d'autres circonstances.
L'QRhi associé doit être en train d'enregistrer un passage de rendu lorsque cette fonction est appelée.
Voir également endPaint().
void QCanvasRhiPaintDriver::resetForNewFrame()
Réinitialise l'état du moteur de rendu. Cette fonction est censée être appelée une seule fois au début d'une nouvelle image, généralement après l'appel de ` QRhi::beginFrame()` ou ` QRhi::beginOffscreenFrame()`.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.