QCanvasRhiPaintDriver Class
Die Klasse „QCanvasRhiPaintDriver“ verwaltet die tiefgreifenden Aspekte der auf „ QCanvasPainter “ basierenden Darstellung für „ QRhi “-Renderziele und Offscreen-Canvases. Mehr...
| Header: | #include <QCanvasRhiPaintDriver> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS CanvasPainter) target_link_libraries(mytarget PRIVATE Qt6::CanvasPainter) |
| Seit: | Qt 6.11 |
Öffentliche Typen
| enum class | BeginPaintFlag { DepthTest } |
| flags | BeginPaintFlags |
| enum class | EndPaintFlag { DoNotRecordRenderPass } |
| flags | EndPaintFlags |
Öffentliche Funktionen
| 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() |
Ausführliche Beschreibung
Anwendungen, die mit „ QCanvasPainter “ auf ein „ QRhi “-basiertes Renderziel rendern möchten – beispielsweise in ein „ QRhiTexture “ oder in den Farbpuffer eines „ QRhiSwapChain “ –, verwenden „ QCanvasPainterFactory “, um einen „ QCanvasPainter “ und einen „QCanvasRhiPaintDriver“ zu initialisieren und abzurufen, die mit dem „ QRhi “ verknüpft sind. Die Zeichen-API wird von QCanvasPainter bereitgestellt, während die Low-Level-Aspekte des Renderings (welches Renderziel, welcher Befehlspuffer usw.) von QCanvasRhiPaintDriver gesteuert werden.
Hinweis: Diese Klasse ist nur relevant, wenn mit QCanvasPainter ohne eine Komfortklasse wie QCanvasPainterWidget oder QCanvasPainterItem gearbeitet wird, da diese der Anwendung eine QCanvasPainter -Instanz bereitstellen und deren Rendering implizit verwalten.
Anwendungen erstellen keine eigenen Instanzen von `QCanvasRhiPaintDriver`. Stattdessen wird diese durch Aufruf von ` paintDriver()` aus einem erfolgreich erstellten ` initialized ` über ` QCanvasPainterFactory ` abgerufen.
Im Folgenden finden Sie eine nahezu vollständige, eigenständige Konsolenanwendung, die einen Kreis in ein „ QRhiTexture “ zeichnet, das Ergebnis ausliest und in einer PNG-Datei speichert:
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;
}Dokumentation zum Mitgliedstyp
enum class QCanvasRhiPaintDriver::BeginPaintFlag
flags QCanvasRhiPaintDriver::BeginPaintFlags
Legt die Flags für ` beginPaint()` fest.
| Konstante | Wert | Beschreibung |
|---|---|---|
QCanvasRhiPaintDriver::BeginPaintFlag::DepthTest | 0x01 | Gibt an, dass beim Rendern die Tiefenprüfung aktiviert werden soll. Normalerweise schreibt oder prüft „ QCanvasPainter “ den Tiefenpuffer nicht. Wenn ein Vergleich mit Werten erforderlich ist, die von einem anderen Renderer geschrieben wurden, setzen Sie dieses Flag. Die verwendete Funktion zum Tiefenvergleich ist „ Less “. |
Der Typ `BeginPaintFlags` ist ein `typedef` für ` QFlags<BeginPaintFlag>`. Er speichert eine ODER-Kombination von `BeginPaintFlag`-Werten.
enum class QCanvasRhiPaintDriver::EndPaintFlag
flags QCanvasRhiPaintDriver::EndPaintFlags
Legt die Flags für ` endPaint()` fest.
| Konstante | Wert | Beschreibung |
|---|---|---|
QCanvasRhiPaintDriver::EndPaintFlag::DoNotRecordRenderPass | 0x01 | Gibt an, dass das Leeren der von „ QCanvasPainter “ generierten Befehle und die Aufzeichnung des „ QRhi “-Renderdurchlaufs nicht gewünscht sind, da anschließend ein expliziter Aufruf von „ renderPaint()“ erfolgt. |
Der Typ `EndPaintFlags` ist ein `typedef` für ` QFlags<EndPaintFlag>`. Er speichert eine OR-Kombination von `EndPaintFlag`-Werten.
Dokumentation der Mitgliedsfunktionen
void QCanvasRhiPaintDriver::beginPaint(QCanvasOffscreenCanvas &canvas, QRhiCommandBuffer *cb, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Beginnt mit dem Zeichnen auf die angegebene Offscreen- canvas und zeichnet die Rendering-Befehle in den Befehlspuffer cb auf.
Hinweis: Aufeinen Aufruf von ` beginPaint()` muss immer ein Aufruf von ` endPaint()` folgen. Eine Verschachtelung wird derzeit nicht unterstützt.
Das Löschen erfolgt über den „ fill color set on the canvas “, es sei denn, das Flag „ QCanvasOffscreenCanvas::Flag::PreserveContents “ ist gesetzt; in diesem Fall findet kein Löschen statt und der Inhalt der Leinwand bleibt erhalten (mit möglichen Auswirkungen auf die Leistung, abhängig von der zugrunde liegenden GPU-Architektur).
Hinweis: Das zugehörige ` QRhi ` muss einen Frame aufzeichnen (es muss entweder `QRhi::beginFrame()` oder ` QRhi::beginOffscreenFrame()` aufgerufen worden sein), darf sich jedoch zum Zeitpunkt des Aufrufs dieser Funktion nicht im Aufzeichnungsmodus für den Render-Pass befinden.
flags Gibt die optionalen Flags an, die das Rendering steuern.
Dies ist eine überladene Funktion.
void QCanvasRhiPaintDriver::beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, const QMatrix4x4 &matrix, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Beginnt mit dem Zeichnen auf das Renderziel rt und zeichnet die Renderbefehle in den Befehlspuffer cb auf.
Diese Überladung akzeptiert eine benutzerdefinierte ` matrix`, die zur Transformation der Scheitelpunkte verwendet wird. Die Matrix muss für Scheitelpunkte geeignet sein, deren Koordinaten in Pixeln angegeben sind. Ein häufiger Anwendungsfall ist die Übergabe der `modelview-projection`-Matrix von ` Qt Quick` bei der Implementierung von ` QCanvasPainter`-basiertem Rendering innerhalb einer Unterklasse von ` QSGRenderNode `.
Die Größe des Ansichtsfensters und das Gerätepixelverhältnis werden aus dem Renderziel übernommen.
Diese Überladung akzeptiert keine Füllfarbe, da in der Praxis davon ausgegangen wird, dass anschließend ein Aufruf von ` endPaint()` mit gesetztem Flag ` EndPaintFlag::DoNotRecordRenderPass ` folgt.
Hinweis: Die Unterstützung für das Clipping ist eingeschränkt, wenn eine benutzerdefinierte Matrix verwendet wird. Rechteckige, nicht transformierte Clips werden unterstützt, wenn die Matrix eine orthogonale Projektion ohne zusätzliche Skalierung oder Drehung festlegt. Es wird generell empfohlen, in diesem Modus auf das Zeichnen unter Verwendung von Clipping zu verzichten.
Hinweis: Aufeinen Aufruf von ` beginPaint()` muss immer ein Aufruf von ` endPaint()` folgen. Eine Verschachtelung wird derzeit nicht unterstützt.
Hinweis: Bei ` rt ` wird erwartet, dass sowohl ein Farb- als auch ein Tiefen-Stencil-Anschluss vorhanden sind. Falls mehrere Farbanschlüsse vorhanden sind, wird nur der Farbpuffer für Anschluss 0 beschrieben. ` QCanvasPainter ` erfordert das Vorhandensein eines Tiefen-Stencil-Puffers. Derzeit wird nur Stencil verwendet; Tiefenprüfung und -beschreibung sind stets deaktiviert.
Hinweis: Das zugehörige ` QRhi ` muss einen Frame aufzeichnen (es muss entweder `QRhi::beginFrame()` oder ` QRhi::beginOffscreenFrame()` aufgerufen worden sein), darf sich jedoch beim Aufruf dieser Funktion nicht im Aufzeichnungsmodus für den Render-Pass befinden.
flags Gibt die optionalen Flags an, die das Rendering steuern.
Dies ist eine überladene Funktion.
void QCanvasRhiPaintDriver::beginPaint(QRhiCommandBuffer *cb, QRhiRenderTarget *rt, QColor fillColor = Qt::black, QSize logicalSize = QSize(), qreal dpr = 1.0, QCanvasRhiPaintDriver::BeginPaintFlags flags = {})
Beginnt mit dem Zeichnen auf das Renderziel rt und speichert dabei die Renderbefehle im Befehlspuffer cb.
fillColor Legt die Farbe fest, die zum Löschen des Farbpuffers verwendet wird. Dieser Wert wird ignoriert, wenn die Flags für endPaint() EndPaintFlag::DoNotRecordRenderPass enthalten.
Hinweis: Aufeinen Aufruf von ` beginPaint()` muss immer ein Aufruf von ` endPaint()` folgen. Eine Verschachtelung wird derzeit nicht unterstützt.
Hinweis: Bei ` rt ` wird erwartet, dass sowohl ein Farb- als auch ein Tiefen-Stencil-Anschluss vorhanden sind. Falls mehrere Farbanschlüsse vorhanden sind, wird nur der Farbpuffer für Anschluss 0 beschrieben. ` QCanvasPainter ` setzt das Vorhandensein eines Tiefen-Stencil-Puffers voraus. Derzeit wird nur der Stencil-Puffer verwendet; Tiefenprüfung und -beschreibung sind stets deaktiviert.
logicalSize ist optional. Ist der Wert nicht leer, gibt er die Größe des Ansichtsfensters in logischen Einheiten an. „ dpr “ muss dann den Skalierungsfaktor (Gerätepixelverhältnis) angeben, damit „ logicalSize “ intern in Pixel umgerechnet werden kann. In der Praxis wird dies selten benötigt, da standardmäßig automatisch die Größe des Renderziels verwendet wird.
Hinweis: Das zugehörige ` QRhi ` muss einen Frame aufzeichnen (`QRhi::beginFrame()` oder ` QRhi::beginOffscreenFrame()` muss aufgerufen worden sein), sollte sich jedoch beim Aufruf dieser Funktion nicht im Aufzeichnungsmodus für den Render-Pass befinden.
flags Gibt die optionalen Flags an, die das Rendering steuern.
Dies ist eine überladene Funktion.
void QCanvasRhiPaintDriver::endPaint(QCanvasRhiPaintDriver::EndPaintFlags flags = {})
Leert den Puffer und zeichnet alle von den Zeichnungsbefehlen „ QCanvasPainter “ erzeugten „ QRhi “-Renderings auf.
Standardmäßig zeichnet diese Funktion einen vollständigen Render-Durchgang auf, d. h., sie ruft intern QRhiCommandBuffer::beginPass() und QRhiCommandBuffer::endPass() auf. Die Löschfarbe wird durch das Argument „fillColor“ von beginPaint() oder durch die Füllfarbe der Offscreen-Leinwand festgelegt.
flags kann verwendet werden, um die Aufzeichnung eines Render-Passes zu steuern, da es in manchen Fällen nicht wünschenswert ist, dass endPaint() eine vollständige beginPass()-endPass()-Sequenz auslöst.
Die folgenden beiden Codeausschnitte liefern identische Ergebnisse, doch der zweite bietet mehr Flexibilität, falls die Anwendung innerhalb desselben Render-Passes weitere Aufgaben ausführen möchte:
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();Siehe auch „ beginPaint()“ und „ renderPaint()“.
template <typename Functor> void QCanvasRhiPaintDriver::grabCanvas(const QCanvasOffscreenCanvas &canvas, const QObject *context, Functor &&callback)
Gibt eine Anforderung zum Zurücklesen einer Textur für „ canvas “ aus und ordnet diese „ context “ zu.
callback wird entweder vor der Rückgabe der Funktion oder später aufgerufen, abhängig von der zugrunde liegenden Implementierung von ` QRhi ` und der 3D-API. Das Zurücklesen von Texturinhalten kann je nach GPU-Architektur eine Kopie von der GPU zur CPU erfordern. Die Funktion nimmt ein einziges ` const QImage & `-Argument entgegen und kann ein beliebiger Funktor sein, einschließlich solcher, die nur eine Verschiebung zulassen.
Wird ` context ` zerstört, bevor das Zurücklesen abgeschlossen ist, wird der Grab-Vorgang abgebrochen und ` callback ` nicht aufgerufen. Dadurch ist es für den Callback sicher, auf Objekte zu verweisen, die möglicherweise nicht länger bestehen als der noch ausstehende Lesevorgang.
Diese Funktion kann sowohl innerhalb eines „ beginPaint() – endPaint()“-Blocks als auch außerhalb aufgerufen werden. Bei einem Aufruf außerhalb des Blocks ruft sie intern „ QRhi::beginOffscreenFrame()“ usw. auf, wodurch „grabs“ jederzeit durchgeführt werden können.
Beispielsweise würde der folgende Code den Inhalt einer nicht im Bildschirmbereich angezeigten Leinwand in einer PNG-Datei speichern:
void QCanvasRhiPaintDriver::renderPaint()
Zeichnet alle durch die Zeichnungsbefehle „ QCanvasPainter “ erzeugten Renderings von „ QRhi “ auf. Rufen Sie diese Funktion nur auf, wenn „ endPaint()“ mit „ DoNotRecordRenderPass “ aufgerufen wurde. Andernfalls darf sie nicht aufgerufen werden.
Das zugehörige ` QRhi ` muss zum Zeitpunkt des Aufrufs dieser Funktion einen Renderdurchlauf aufzeichnen.
Siehe auch endPaint().
void QCanvasRhiPaintDriver::resetForNewFrame()
Setzt den Status der Painter-Engine zurück. Diese Funktion sollte einmal beim Start eines komplett neuen Frames aufgerufen werden, typischerweise nach ` QRhi::beginFrame()` oder ` 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.