QRhiSwapChain Class

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

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

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

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

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

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

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

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

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

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

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

Fonction membre Documentation

[pure virtual] bool QRhiSwapChain::createOrResize()

Crée la chaîne d'échange si ce n'est pas déjà fait et redimensionne les tampons de la chaîne d'échange pour qu'ils correspondent à la taille actuelle de la surface cible. Appeler cette fonction chaque fois que la taille de la surface cible est différente de la précédente.

Retourne true en cas de succès, false en cas d'échec d'une opération graphique. Quelle que soit la valeur de retour, l'appel à destroy() est toujours sûr.

[pure virtual] QRhiCommandBuffer *QRhiSwapChain::currentFrameCommandBuffer()

Renvoie un tampon de commande sur lequel les commandes de rendu et les mises à jour de ressources peuvent être enregistrées dans un bloc beginFrame - endFrame, en supposant que beginFrame() a été appelé avec cette chaîne d'échange.

[pure virtual] QRhiRenderTarget *QRhiSwapChain::currentFrameRenderTarget()

Renvoie une cible de rendu qui peut être utilisée avec beginPass() afin de rendre le backbuffer actuel de la chaîne d'échange. Valable uniquement dans un bloc QRhi::beginFrame() - QRhi::endFrame() où beginFrame() a été appelé avec cette chaîne d'échange.

[virtual] QRhiRenderTarget *QRhiSwapChain::currentFrameRenderTarget(QRhiSwapChain::StereoTargetBuffer targetBuffer)

Renvoie une cible de rendu qui peut être utilisée avec beginPass() afin d'effectuer le rendu dans le backbuffer gauche ou droit de la chaîne d'échange. Cette surcharge ne doit être utilisée qu'avec un rendu stéréoscopique, c'est-à-dire lorsque le site QWindow associé est soutenu par deux tampons de couleur, un pour chaque oeil, au lieu d'un seul.

Si le rendu stéréoscopique n'est pas pris en charge, la valeur de retour sera la cible par défaut. Il est supporté par tous les backends matériels à l'exception de Metal, en combinaison avec QSurfaceFormat::StereoBuffers, en supposant qu'il soit supporté par la pile de pilotes graphiques et d'affichage au moment de l'exécution. Les backends Metal et Null renverront la cible de rendu par défaut à partir de cette surcharge.

QSize QRhiSwapChain::currentPixelSize() const

Renvoie la taille avec laquelle la chaîne d'échange a été construite pour la dernière fois avec succès. Utilisez cette fonction pour décider si createOrResize() doit être appelé à nouveau : si currentPixelSize() != surfacePixelSize(), la chaîne d'échange doit être redimensionnée.

Bien que dans de nombreux cas, la valeur soit la même que celle de QWindow::size() * QWindow::devicePixelRatio(), il n'est pas garanti que la taille rapportée par QWindow soit correcte sur toutes les plates-formes et dans toutes les implémentations d'API graphiques. Il est donc fortement recommandé d'utiliser cette fonction chaque fois qu'il est nécessaire d'identifier les dimensions, en pixels, de la couche ou de la surface de sortie.

Cela présente également l'avantage d'éviter les courses aux données potentielles lorsque QRhi est utilisé sur un thread de rendu dédié, car la nécessité d'appeler les fonctions QWindow, qui peuvent alors accéder aux données mises à jour sur le thread principal, est évitée.

Voir également surfacePixelSize().

QRhiRenderBuffer *QRhiSwapChain::depthStencil() const

Renvoie le tampon de rendu actuellement associé au crayon de profondeur.

Voir aussi setDepthStencil().

QRhiSwapChain::Flags QRhiSwapChain::flags() const

Renvoie les drapeaux actuellement définis.

Voir aussi setFlags().

QRhiSwapChain::Format QRhiSwapChain::format() const

Renvoie le format actuellement défini.

Voir aussi setFormat().

[virtual] QRhiSwapChainHdrInfo QRhiSwapChain::hdrInfo()

Renvoie les informations HDR pour l'écran associé.

Ne pensez pas qu'il s'agit d'une opération peu coûteuse. En fonction de la plate-forme, cette fonction effectue diverses requêtes de plate-forme qui peuvent avoir un impact sur les performances.

Voir également QRhiSwapChainHdrInfo.

[pure virtual] bool QRhiSwapChain::isFormatSupported(QRhiSwapChain::Format f)

Renvoie un résultat positif si le format de chaîne d'échange donné f est pris en charge. SDR est toujours pris en charge.

La principale utilisation de cette fonction est de l'appeler avant le premier createOrResize() après que la fenêtre a déjà été définie. Cela permet aux backends de QRhi d'effectuer des requêtes spécifiques à la plateforme ou au système de fenêtrage pour déterminer si la fenêtre (et l'écran sur lequel elle se trouve) est capable d'une véritable sortie HDR avec le format spécifié.

Lorsque le format est signalé comme étant pris en charge, appelez setFormat() pour définir le format demandé et appelez createOrResize(). Soyez toutefois conscient des conséquences : si vous réussissez à demander un format HDR, vous devrez gérer un espace colorimétrique différent, éventuellement effectuer une correction du niveau de blanc pour le contenu non compatible avec le HDR, ajuster les méthodes de mise en correspondance des tons, ajuster les paramètres de la cible de rendu hors écran, etc.

Voir également setFormat().

[pure virtual] QRhiRenderPassDescriptor *QRhiSwapChain::newCompatibleRenderPassDescriptor()

Renvoie un nouveau QRhiRenderPassDescriptor compatible avec cette chaîne d'échange.

La valeur renvoyée est utilisée de deux manières : elle peut être transmise à setRenderPassDescriptor() et QRhiGraphicsPipeline::setRenderPassDescriptor(). Un descripteur de passe de rendu décrit les pièces jointes (couleur, profondeur/stencil) et le comportement de chargement/stockage qui peuvent être affectés par flags(). Un QRhiGraphicsPipeline ne peut être utilisé qu'en combinaison avec une chaîne d'échange qui a un ensemble compatible QRhiRenderPassDescriptor .

Voir également createOrResize().

QRhiSwapChainProxyData QRhiSwapChain::proxyData() const

Renvoie les données proxy actuellement définies.

Voir aussi setProxyData().

QRhiRenderPassDescriptor *QRhiSwapChain::renderPassDescriptor() const

Renvoie l'objet QRhiRenderPassDescriptor actuellement associé.

Voir aussi setRenderPassDescriptor().

[override virtual] QRhiResource::Type QRhiSwapChain::resourceType() const

Réimplémente : QRhiResource::resourceType() const.

Renvoie le type de ressource.

int QRhiSwapChain::sampleCount() const

Renvoie le nombre d'échantillons actuellement défini. 1 signifie qu'il n'y a pas d'anti-crénelage multi-échantillon.

Voir aussi setSampleCount().

void QRhiSwapChain::setDepthStencil(QRhiRenderBuffer *ds)

Définit le tampon de rendu ds pour une utilisation en tant que tampon de profondeur.

Voir aussi depthStencil().

void QRhiSwapChain::setFlags(QRhiSwapChain::Flags f)

Définit les drapeaux f.

Voir aussi flags().

void QRhiSwapChain::setFormat(QRhiSwapChain::Format f)

Définit le format f.

Evitez de définir des formats qui sont signalés comme non supportés par isFormatSupported(). Notez que la prise en charge d'un format donné peut dépendre de l'écran sur lequel la fenêtre associée à la chaîne d'échange est ouverte. Sur certaines plateformes, telles que Windows et macOS, pour que la sortie HDR fonctionne, il est nécessaire que la sortie HDR soit activée dans les paramètres d'affichage.

Voir isFormatSupported(), QRhiSwapChainHdrInfo, et Format pour plus d'informations sur la sortie HDR.

Voir également format().

void QRhiSwapChain::setProxyData(const QRhiSwapChainProxyData &d)

Définit les données proxy d.

Voir aussi proxyData() et QRhi::updateSwapChainProxyData().

void QRhiSwapChain::setRenderPassDescriptor(QRhiRenderPassDescriptor *desc)

Associé au site QRhiRenderPassDescriptor desc .

Voir aussi renderPassDescriptor().

void QRhiSwapChain::setSampleCount(int samples)

Définit le nombre d'échantillons. Les valeurs courantes pour samples sont 1 (pas de MSAA), 4 (4x MSAA) ou 8 (8x MSAA).

Voir également sampleCount() et QRhi::supportedSampleCounts().

[since 6.9] void QRhiSwapChain::setShadingRateMap(QRhiShadingRateMap *map)

S'associe à l'adresse QRhiShadingRateMap map spécifiée. Ceci n'est fonctionnel que lorsque la fonctionnalité QRhi::VariableRateShadingMap est signalée comme étant prise en charge.

Lorsque QRhiCommandBuffer::setShadingRate() est également appelé, le plus élevé des deux taux d'ombrage est utilisé pour chaque tuile. Il n'existe actuellement aucun contrôle sur le comportement du combinateur.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi shadingRateMap().

void QRhiSwapChain::setWindow(QWindow *window)

Définit la valeur de window.

Voir aussi window().

[since 6.9] QRhiShadingRateMap *QRhiSwapChain::shadingRateMap() const

Renvoie l'adresse QRhiShadingRateMap actuellement définie. Par défaut, il s'agit de nullptr.

Cette fonction a été introduite dans Qt 6.9.

Voir aussi setShadingRateMap().

[pure virtual] QSize QRhiSwapChain::surfacePixelSize()

Renvoie la taille de la surface ou du calque associé à la fenêtre.

Voir également currentPixelSize().

QWindow *QRhiSwapChain::window() const

Renvoie la fenêtre actuellement définie.

Voir aussi setWindow().