QRhiWidget Class

class ExampleRhiWidget : public QRhiWidget
{
public:
    ExampleRhiWidget(QWidget *parent = nullptr) : QRhiWidget(parent) { }
    void initialize(QRhiCommandBuffer *cb) override;
    void render(QRhiCommandBuffer *cb) override;
private:
    QRhi *m_rhi = nullptr;
    std::unique_ptr<QRhiBuffer> m_vbuf;
    std::unique_ptr<QRhiBuffer> m_ubuf;
    std::unique_ptr<QRhiShaderResourceBindings> m_srb;
    std::unique_ptr<QRhiGraphicsPipeline> m_pipeline;
    QMatrix4x4 m_viewProjection;
    float m_rotation = 0.0f;
};

float vertexData[] = {
     0.0f,   0.5f,     1.0f, 0.0f, 0.0f,
    -0.5f,  -0.5f,     0.0f, 1.0f, 0.0f,
     0.5f,  -0.5f,     0.0f, 0.0f, 1.0f,
};

QShader getShader(const QString &name)
{
    QFile f(name);
    return f.open(QIODevice::ReadOnly) ? QShader::fromSerialized(f.readAll()) : QShader();
}

void ExampleRhiWidget::initialize(QRhiCommandBuffer *cb)
{
    if (m_rhi != rhi()) {
        m_pipeline.reset();
        m_rhi = rhi();
    }

    if (!m_pipeline) {
        m_vbuf.reset(m_rhi->newBuffer(QRhiBuffer::Immutable, QRhiBuffer::VertexBuffer, sizeof(vertexData)));
        m_vbuf->create();

        m_ubuf.reset(m_rhi->newBuffer(QRhiBuffer::Dynamic, QRhiBuffer::UniformBuffer, 64));
        m_ubuf->create();

        m_srb.reset(m_rhi->newShaderResourceBindings());
        m_srb->setBindings({
            QRhiShaderResourceBinding::uniformBuffer(0, QRhiShaderResourceBinding::VertexStage, m_ubuf.get()),
        });
        m_srb->create();

        m_pipeline.reset(m_rhi->newGraphicsPipeline());
        m_pipeline->setShaderStages({
            { QRhiShaderStage::Vertex, getShader(QLatin1String(":/shader_assets/color.vert.qsb")) },
            { QRhiShaderStage::Fragment, getShader(QLatin1String(":/shader_assets/color.frag.qsb")) }
        });
        QRhiVertexInputLayout inputLayout;
        inputLayout.setBindings({
            { 5 * sizeof(float) }
        });
        inputLayout.setAttributes({
            { 0, 0, QRhiVertexInputAttribute::Float2, 0 },
            { 0, 1, QRhiVertexInputAttribute::Float3, 2 * sizeof(float) }
        });
        m_pipeline->setVertexInputLayout(inputLayout);
        m_pipeline->setShaderResourceBindings(m_srb.get());
        m_pipeline->setRenderPassDescriptor(renderTarget()->renderPassDescriptor());
        m_pipeline->create();

        QRhiResourceUpdateBatch *resourceUpdates = m_rhi->nextResourceUpdateBatch();
        resourceUpdates->uploadStaticBuffer(m_vbuf.get(), vertexData);
        cb->resourceUpdate(resourceUpdates);
    }

    const QSize outputSize = colorTexture()->pixelSize();
    m_viewProjection = m_rhi->clipSpaceCorrMatrix();
    m_viewProjection.perspective(45.0f, outputSize.width() / (float) outputSize.height(), 0.01f, 1000.0f);
    m_viewProjection.translate(0, 0, -4);
}

void ExampleRhiWidget::render(QRhiCommandBuffer *cb)
{
    QRhiResourceUpdateBatch *resourceUpdates = m_rhi->nextResourceUpdateBatch();
    m_rotation += 1.0f;
    QMatrix4x4 modelViewProjection = m_viewProjection;
    modelViewProjection.rotate(m_rotation, 0, 1, 0);
    resourceUpdates->updateDynamicBuffer(m_ubuf.get(), 0, 64, modelViewProjection.constData());

    const QColor clearColor = QColor::fromRgbF(0.4f, 0.7f, 0.0f, 1.0f);
    cb->beginPass(renderTarget(), clearColor, { 1.0f, 0 }, resourceUpdates);

    cb->setGraphicsPipeline(m_pipeline.get());
    const QSize outputSize = colorTexture()->pixelSize();
    cb->setViewport(QRhiViewport(0, 0, outputSize.width(), outputSize.height()));
    cb->setShaderResources();
    const QRhiCommandBuffer::VertexInput vbufBinding(m_vbuf.get(), 0);
    cb->setVertexInput(0, 1, &vbufBinding);
    cb->draw(3);

    cb->endPass();

    update();
}

#version 440
layout(location = 0) in vec4 position;
layout(location = 1) in vec3 color;
layout(location = 0) out vec3 v_color;
layout(std140, binding = 0) uniform buf {
    mat4 mvp;
};

void main()
{
    v_color = color;
    gl_Position = mvp * position;
}

#version 440
layout(location = 0) in vec3 v_color;
layout(location = 0) out vec4 fragColor;

void main()
{
    fragColor = vec4(v_color, 1.0);
}

Dokumentation der Mitgliedsfunktionen

[explicit] QRhiWidget::QRhiWidget(QWidget *parent = nullptr, Qt::WindowFlags f = {})

Erstellt ein Widget, das ein untergeordnetes Element von ` parent` ist, wobei die Widget-Flags auf ` f` gesetzt sind.

[override virtual noexcept] QRhiWidget::~QRhiWidget()

Destruktor.

QRhiWidget::Api QRhiWidget::api() const

Gibt die aktuell eingestellte Grafik-API zurück (QRhi -Backend).

Siehe auch setApi().

[protected] QRhiTexture *QRhiWidget::colorTexture() const

Gibt die Textur zurück, die als Farbpuffer für das Widget dient.

Darf nur von ` initialize()` und ` render()` aufgerufen werden.

Im Gegensatz zum Depth-Stencil-Puffer und dem ` QRhiRenderTarget` ist diese Textur immer verfügbar und wird vom ` QRhiWidget` verwaltet, unabhängig vom Wert von ` autoRenderTarget`.

Siehe auch msaaColorBuffer(), depthStencilBuffer(), renderTarget() und resolveTexture().

[protected] QRhiRenderBuffer *QRhiWidget::depthStencilBuffer() const

Gibt den Depth-Stencil-Puffer zurück, der für die Darstellung des Widgets verwendet wird.

Darf nur von ` initialize()` und ` render()` aufgerufen werden.

Nur verfügbar, wenn autoRenderTarget gleich true ist. Andernfalls ist der Rückgabewert nullptr, und es obliegt der Neuimplementierung von initialize(), einen Tiefen-Stencil-Puffer und einen QRhiTextureRenderTarget zu erstellen und zu verwalten.

Siehe auch colorTexture() und renderTarget().

[override virtual protected] bool QRhiWidget::event(QEvent *e)

Umsetzt: ` QWidget::event(QEvent *event)`.

[signal] void QRhiWidget::frameSubmitted()

Dieses Signal wird ausgelöst, nachdem das oberste Fenster des Widgets die Komposition abgeschlossen hat und sich im Status „ submitted a frame “ befindet.

QImage QRhiWidget::grabFramebuffer() const

Rendert ein neues Bild, liest den Inhalt der Textur zurück und gibt ihn als ` QImage` zurück.

Wenn ein Fehler auftritt, wird ein null- QImage zurückgegeben.

Das zurückgegebene ` QImage ` hat das Format ` QImage::Format_RGBA8888`, ` QImage::Format_RGBA16FPx4`, ` QImage::Format_RGBA32FPx4` oder ` QImage::Format_BGR30`, abhängig von ` colorBufferFormat()`.

QRhiWidget kennt die Vorgehensweise des Renderers bei der Überblendung und Komposition nicht und kann daher nicht wissen, ob die Ausgabe in den RGB-Farbwerten mit Alpha-Kanal vorvervielfacht ist. Daher werden die Formate _Premultiplied und QImage niemals für das zurückgegebene QImage verwendet, selbst wenn dies angemessen wäre. Es obliegt dem Aufrufer, die resultierenden Daten nach eigenem Ermessen neu zu interpretieren.

Die Funktion heißt grabFramebuffer(), um die Konsistenz mit QOpenGLWidget und QQuickWidget zu wahren. Dies ist nicht die einzige Möglichkeit, CPU-seitige Bilddaten aus dem Inhalt des QRhiWidget zu extrahieren: Der Aufruf von QWidget::grab() auf einem QRhiWidget oder einem dessen Vorfahren funktioniert ebenfalls (und gibt ein QPixmap zurück). Neben der direkten Arbeit mit ` QImage` besteht ein weiterer Vorteil von `grabFramebuffer()` darin, dass es möglicherweise etwas leistungsfähiger ist, einfach weil es nicht den Rest der ` QWidget `-Infrastruktur durchlaufen muss, sondern sofort das Rendern eines neuen Frames auslösen und anschließend das Zurücklesen durchführen kann.

Siehe auch setColorBufferFormat().

[virtual protected] void QRhiWidget::initialize(QRhiCommandBuffer *cb)

Wird aufgerufen, wenn das Widget zum ersten Mal initialisiert wird, wenn sich die Größe, das Format oder die Anzahl der Samples der zugehörigen Textur ändert oder wenn sich die „ QRhi “ und die Textur aus irgendeinem Grund ändern. Von der Funktion wird erwartet, dass sie die vom Rendering-Code in ` render()` verwendeten Grafikressourcen verwaltet (erstellt, falls noch nicht vorhanden, anpasst und neu erstellt, falls sich die Größe geändert hat).

Um den „ QRhi “, „ QRhiTexture “ und andere zugehörige Objekte abzufragen, rufen Sie „ rhi()“, „ colorTexture()“, „ depthStencilBuffer()“ und „ renderTarget()“ auf.

Wenn sich die Größe des Widgets ändert, sind das ` QRhi `-Objekt, die Farbpuffer-Textur sowie die Objekte für den Tiefen- und Stencil-Puffer zwar dieselben Instanzen wie zuvor (sodass die Getter dieselben Zeiger zurückgeben), doch wurden die Farb- sowie die Tiefen- und Stencil-Puffer wahrscheinlich neu aufgebaut, was bedeutet, dass sich ` size ` und die zugrunde liegende native Texturressource möglicherweise von denen beim letzten Aufruf unterscheiden.

Reimplementierungen sollten zudem darauf vorbereitet sein, dass sich das „ QRhi “-Objekt und die Farbpuffertextur zwischen den Aufrufen dieser Funktion ändern können. Ein Sonderfall, in dem die Objekte unterschiedlich sind, tritt auf, wenn ein „ grabFramebuffer()“ mit einem noch nicht angezeigten Widget durchgeführt wird und das Widget anschließend innerhalb eines Top-Level-Widgets auf dem Bildschirm sichtbar gemacht wird. Dort erfolgt die Erfassung mit einem dedizierten ` QRhi `, das dann bei nachfolgenden Aufrufen von `initialize()` und ` render()` durch das zugehörige ` QRhi ` des Top-Level-Fensters ersetzt wird. Ein weiterer, häufigerer Fall tritt auf, wenn das Widget einem neuen Top-Level-Fenster zugeordnet wird. In diesem Fall sind das ` QRhi ` und alle zugehörigen Ressourcen, die vom ` QRhiWidget ` verwaltet werden, beim nachfolgenden Aufruf dieser Funktion andere Instanzen als zuvor. Es ist daher wichtig, dass alle vorhandenen ` QRhi `-Ressourcen, die zuvor von der Unterklasse erstellt wurden, zerstört werden, da sie zum vorherigen ` QRhi ` gehören, das vom Widget nicht mehr verwendet werden sollte.

Wenn „ autoRenderTarget “ auf „ true “ gesetzt ist – was die Standardeinstellung ist –, werden ein Depth-Stencil- QRhiRenderBuffer und ein „ QRhiTextureRenderTarget “, die mit „ colorTexture()“ (oder „ msaaColorBuffer(“)) verknüpft sind, sowie der Depth-Stencil-Puffer automatisch erstellt und verwaltet. Reimplementierungen von „initialize()“ und „ render()“ können diese Objekte über „ depthStencilBuffer()“ und „ renderTarget()“ abfragen. Wenn „ autoRenderTarget “ auf „ false “ gesetzt ist, werden diese Objekte nicht mehr automatisch erstellt und verwaltet. Stattdessen obliegt es der Implementierung von `initialize()`, Puffer zu erstellen und das Renderziel nach eigenem Ermessen einzurichten. Bei der manuellen Verwaltung zusätzlicher Farb- oder Tiefen-Stencil-Anhänge für das Renderziel müssen deren Größe und Sample-Anzahl stets der Größe und Sample-Anzahl von ` colorTexture()` bzw. ` msaaColorBuffer()` entsprechen; andernfalls können Fehler beim Rendern oder bei der Validierung durch die 3D-API auftreten.

Es wird erwartet, dass die von der Unterklasse erstellten Grafikressourcen in der Destruktor-Implementierung der Unterklasse freigegeben werden.

cb ist der „ QRhiCommandBuffer “ für den aktuellen Frame des Widgets. Die Funktion wird aufgerufen, während ein Frame aufgezeichnet wird, jedoch ohne aktiven Render-Pass. Der Befehlspuffer dient in erster Linie dazu, „ resource updates “ in die Warteschlange einzureihen, ohne auf „ render()“ zurückzugreifen.

Siehe auch ` render()`.

bool QRhiWidget::isDebugLayerEnabled() const

Gibt „true“ zurück, wenn eine Debug- oder Validierungsschicht angefordert wird, sofern dies für die verwendete Grafik-API zutrifft.

Siehe auch ` setDebugLayerEnabled()`.

[protected] QRhiRenderBuffer *QRhiWidget::msaaColorBuffer() const

Gibt den Renderbuffer zurück, der als Multisample-Farbpuffer für das Widget dient.

Darf nur von „ initialize()“ und „ render()“ aufgerufen werden.

Wenn ` sampleCount ` größer als 1 ist und somit Multisample-Antialiasing aktiviert ist, hat der zurückgegebene ` QRhiRenderBuffer ` eine entsprechende Sample-Anzahl und dient als Farbpuffer. Grafikpipelines, die zum Rendern in diesen Puffer verwendet werden, müssen mit derselben Sample-Anzahl erstellt werden, und die Sample-Anzahl des Depth-Stencil-Puffers muss ebenfalls übereinstimmen. Es wird erwartet, dass der Multisample-Inhalt in die von ` resolveTexture()` zurückgegebene Textur aufgelöst wird. Wenn ` autoRenderTarget ` auf ` true` gesetzt ist, wird ` renderTarget()` automatisch entsprechend eingerichtet, indem `msaaColorBuffer()` als ` renderbuffer ` der Farbzuordnung 0 und ` resolveTexture()` als deren ` resolveTexture` festgelegt werden.

Wenn MSAA nicht verwendet wird, lautet der Rückgabewert „ nullptr “. Verwenden Sie in diesem Fall stattdessen „ colorTexture()“.

Je nach der zugrunde liegenden 3D-Grafik-API gibt es möglicherweise keinen praktischen Unterschied zwischen Multisample-Texturen und Farb-Renderbuffern mit einer Sample-Anzahl größer als 1 (QRhi ordnet möglicherweise beide einfach demselben nativen Ressourcentyp zu). Einige ältere APIs unterscheiden jedoch möglicherweise zwischen Texturen und Renderbuffern. Um OpenGL ES 3.0 zu unterstützen, wo Multisample-Renderbuffer verfügbar sind, Multisample-Texturen jedoch nicht, führt QRhiWidget MSAA immer unter Verwendung eines Multisample- QRhiRenderBuffer s als Farb-Attachment durch (und niemals eines Multisample- QRhiTexture s).

Siehe auch colorTexture(), depthStencilBuffer(), renderTarget() und resolveTexture().

[override virtual protected] void QRhiWidget::paintEvent(QPaintEvent *e)

Implementiert: ` QWidget::paintEvent` (`QPaintEvent *event`).

Behandelt Zeichenereignisse.

Der Aufruf von ` QWidget::update()` führt zum Senden eines Zeichenereignisses ` e` und damit zum Aufruf dieser Funktion. Das Senden des Ereignisses erfolgt asynchron und findet zu einem Zeitpunkt nach der Rückkehr aus ` update()` statt. Diese Funktion ruft dann nach einigen Vorbereitungen die virtuelle Funktion ` render()` auf, um den Inhalt der mit dem ` QRhiWidget` verknüpften Textur zu aktualisieren. Das oberste Fenster des Widgets fügt die Textur anschließend mit dem Rest des Fensters zusammen.

[virtual protected] void QRhiWidget::releaseResources()

Wird aufgerufen, wenn die Grafikressourcen vorzeitig freigegeben werden müssen.

Dies tritt normalerweise nicht bei einem „ QRhiWidget “ auf, das der Kindhierarchie eines Top-Level-Widgets hinzugefügt wird und dort für den Rest seiner Lebensdauer sowie der des Top-Level-Widgets verbleibt. Daher ist es in vielen Fällen nicht erforderlich, diese Funktion neu zu implementieren, z. B. weil die Anwendung immer nur ein einziges Top-Level-Widget (natives Fenster) besitzt. Wenn jedoch eine Umordnung des Widgets (oder eines seiner Vorfahren) stattfindet, wird die Neuimplementierung dieser Funktion in robusten, gut geschriebenen Unterklassen von ` QRhiWidget ` erforderlich.

Wenn diese Funktion aufgerufen wird, wird von der Implementierung erwartet, dass sie alle Ressourcen von „ QRhi “ (Objekte vom Typ „QRhiBuffer “, „ QRhiTexture “ usw.) freigibt, ähnlich wie dies im Destruktor erwartet wird. Das Setzen auf NULL, die Verwendung eines Smart-Pointers oder das Setzen eines „ resources-invalid “-Flags ist ebenfalls erforderlich, da „ initialize()“ anschließend aufgerufen wird. Beachten Sie jedoch, dass es falsch ist, die Freigabe von Ressourcen auf den nachfolgenden Aufruf von ` initialize()` zu verschieben. Wenn diese Funktion aufgerufen wird, muss die Ressource vor der Rückkehr freigegeben werden. Beachten Sie außerdem, dass die Implementierung dieser Funktion den Klassen-Destruktor (oder Smart-Pointer) nicht ersetzt: Die Grafikressourcen müssen weiterhin in beiden Fällen freigegeben werden.

Ein Beispiel hierfür in der Praxis finden Sie im Beispiel „Cube RHI Widget “. Dort löst die Schaltfläche, die den „ QRhiWidget “ zwischen dem Status als untergeordnetes Widget (da es ein übergeordnetes Widget hat) und dem Status als Widget der obersten Ebene (da es kein übergeordnetes Widget hat) umschaltet, den Aufruf dieser Funktion aus, da sich das zugehörige Widget der obersten Ebene, das native Fenster, und „ QRhi “ sich alle während der Lebensdauer des „ QRhiWidget “ ändern, wobei das zuvor verwendete „ QRhi “ zerstört wird, was eine vorzeitige Freigabe der zugehörigen Ressourcen zur Folge hat, die vom noch aktiven „ QRhiWidget “ verwaltet werden.

Ein weiterer Fall, in dem diese Funktion aufgerufen wird, tritt ein, wenn ` grabFramebuffer()` mit einem ` QRhiWidget ` verwendet wird, das keinem sichtbaren Fenster hinzugefügt wurde, d. h., die Darstellung erfolgt außerhalb des Bildschirms. Wird dieses ` QRhiWidget ` später sichtbar gemacht oder einer sichtbaren Widget-Hierarchie hinzugefügt, wechselt der zugehörige ` QRhi ` von dem für die Offscreen-Darstellung verwendeten temporären zu dem für das Fenster bestimmten, wodurch ebenfalls diese Funktion ausgelöst wird.

Siehe auch ` initialize()`.

[virtual protected] void QRhiWidget::render(QRhiCommandBuffer *cb)

Wird aufgerufen, wenn der Inhalt des Widgets (d. h. der Inhalt der Textur) aktualisiert werden muss.

Es erfolgt immer mindestens ein Aufruf von ` initialize()` (), bevor diese Funktion aufgerufen wird.

Um Aktualisierungen anzufordern, rufen Sie ` QWidget::update()` auf. Der Aufruf von ` update()` innerhalb von `render()` führt zu einer kontinuierlichen Aktualisierung, die durch Vsync gedrosselt wird.

cb ist die ` QRhiCommandBuffer ` für den aktuellen Frame des Widgets. Die Funktion wird aufgerufen, während ein Frame aufgezeichnet wird, jedoch ohne aktiven Render-Durchlauf.

Siehe auch initialize().

[signal] void QRhiWidget::renderFailed()

Dieses Signal wird immer dann ausgelöst, wenn das Widget auf seine Hintergrundtextur gerendert werden soll (entweder aufgrund eines „ widget update “ oder aufgrund eines Aufrufs von „ grabFramebuffer()“), aber keine „ QRhi “ für das Widget zur Verfügung steht, was wahrscheinlich auf Probleme im Zusammenhang mit der Grafikkonfiguration zurückzuführen ist.

Dieses Signal kann bei Auftreten eines Problems mehrfach ausgelöst werden. Gehen Sie nicht davon aus, dass es nur einmal ausgelöst wird. Verwenden Sie „ Qt::SingleShotConnection “, wenn der Fehlerbehandlungscode nur einmal benachrichtigt werden soll.

[protected] QRhiRenderTarget *QRhiWidget::renderTarget() const

Gibt das Render-Target-Objekt zurück, das bei Neaimplementierungen von ` render()` zusammen mit ` QRhiCommandBuffer::beginPass()` verwendet werden muss.

Darf nur von ` initialize()` und ` render()` aufgerufen werden.

Nur verfügbar, wenn ` autoRenderTarget ` gleich ` true` ist. Andernfalls lautet der Rückgabewert ` nullptr `, und es obliegt der Neuimplementierung von ` initialize()` (), einen Depth-Stencil-Puffer und einen ` QRhiTextureRenderTarget` zu erstellen und zu verwalten.

Beim Erstellen von „ graphics pipelines “ wird ein „ QRhiRenderPassDescriptor “ benötigt. Dieser kann über den zurückgegebenen „ QRhiTextureRenderTarget “ durch Aufruf von „ renderPassDescriptor()“ abgefragt werden.

Siehe auch colorTexture() und depthStencilBuffer().

[override virtual protected] void QRhiWidget::resizeEvent(QResizeEvent *e)

Implementiert: ` QWidget::resizeEvent(QResizeEvent *event)`.

Behandelt Größenänderungsereignisse, die über den Ereignisparameter „ e “ übergeben werden. Ruft die virtuelle Funktion „ initialize()“ auf.

[protected] QRhiTexture *QRhiWidget::resolveTexture() const

Gibt die Nicht-Multisample-Textur zurück, auf die der Multisample-Inhalt aufgelöst wird.

Das Ergebnis ist „ nullptr “, wenn Multisample-Antialiasing nicht aktiviert ist.

Darf nur von „ initialize()“ und „ render()“ aufgerufen werden.

Bei aktiviertem MSAA ist dies die Textur, die mit dem restlichen „ QWidget “-Inhalt auf dem Bildschirm zusammengesetzt wird. Das Rendering von „ QRhiWidget “ muss jedoch auf das (Multisample-)„ QRhiRenderBuffer “ abzielen, das von „ msaaColorBuffer()“ zurückgegeben wird. Wenn „ autoRenderTarget “ auf „ true “ gesetzt ist, wird dies durch das von „ renderTarget()“ zurückgegebene „ QRhiRenderTarget “ übernommen. Andernfalls ist es Aufgabe des Unterklassen-Codes, ein Render-Target-Objekt korrekt zu konfigurieren, das sowohl den Farbpuffer als auch die aufgelösten Texturen enthält.

Siehe auch ` colorTexture()`.

[protected] QRhi *QRhiWidget::rhi() const

Gibt das aktuelle „ QRhi “-Objekt zurück.

Darf nur von „ initialize()“ und „ render()“ aufgerufen werden.

void QRhiWidget::setApi(QRhiWidget::Api api)

Legt die zu verwendende Grafik-API und das Backend „ QRhi “ auf „ api “ fest.

Der Standardwert hängt von der Plattform ab: Metal unter macOS und iOS, Direct 3D 11 unter Windows, ansonsten OpenGL.

Die „ api “ kann für das Widget und dessen oberstes Fenster nur einmal festgelegt werden. Sobald dies geschehen ist und in Kraft tritt, kann das Fenster zum Rendern nur noch diese API und das „ QRhi “-Backend verwenden. Der Versuch, einen anderen Wert festzulegen oder ein weiteres „ QRhiWidget “ mit einer anderen „ api “ hinzuzufügen, funktioniert nicht wie erwartet.

Siehe auch setColorBufferFormat(), setDebugLayerEnabled() und api().

[protected] void QRhiWidget::setAutoRenderTarget(bool enabled)

Legt fest, ob ein Tiefen-Stencil- QRhiRenderBuffer und ein QRhiTextureRenderTarget vom Widget automatisch erstellt und verwaltet werden. Der Standardwert ist „ true “.

Im automatischen Modus richten sich die Größe und die Anzahl der Samples des Depth-Stencil-Puffers nach den Einstellungen der Farbpuffer-Textur. Im nicht-automatischen Modus geben „ renderTarget()“ und „ depthStencilBuffer()“ stets „ nullptr “ zurück, und es obliegt dann der Implementierung von „ initialize()“ in der Anwendung, die Einrichtung und Verwaltung dieser Objekte zu übernehmen.

Rufen Sie diese Funktion frühzeitig auf – beispielsweise im Konstruktor der abgeleiteten Klasse –, wobei ` enabled ` auf ` false ` gesetzt sein muss, um den automatischen Modus zu deaktivieren.

void QRhiWidget::setDebugLayerEnabled(bool enable)

Fordert die Debug- oder Validierungsschicht der zugrunde liegenden Grafik-API an, wenn „ enable “ auf „true“ gesetzt ist.

Gilt für Vulkan und Direct 3D.

Standardmäßig ist diese Funktion deaktiviert.

Siehe auch „ setApi()“ und „ isDebugLayerEnabled()“.