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();
}

Documentation des fonctions membres

[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 les adapter à la taille actuelle de la surface cible. Appelez cette fonction chaque fois que la taille de la surface cible diffère de celle d'auparavant.

Renvoie ` true ` en cas de succès, ` false ` lorsqu’une opération graphique a échoué. Quelle que soit la valeur renvoyée, l’appel à ` destroy()` est toujours sans risque.

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

Renvoie un tampon de commandes dans lequel les commandes de rendu et les mises à jour de ressources peuvent être enregistrées au sein d’un bloc « beginFrame » - endFrame, à condition que la fonction beginFrame() ait été appelée avec cette chaîne d’échange.

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

Renvoie une cible de rendu pouvant être utilisée avec la fonction `beginPass()` afin de rendre le tampon arrière actuel de la chaîne d'échange. Valable uniquement au sein d'un bloc ` QRhi::beginFrame()` - ` QRhi::endFrame()` dans lequel la fonction `beginFrame()` a été appelée avec cette chaîne d'échange.

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

Renvoie une cible de rendu pouvant être utilisée avec la fonction `beginPass()` afin d'effectuer le rendu vers le tampon arrière gauche ou droit de la chaîne d'échange. Cette surcharge ne doit être utilisée qu'avec le rendu stéréoscopique, c'est-à-dire lorsque la chaîne d'échange associée ( QWindow ) s'appuie sur deux tampons de couleur, un pour chaque œil, au lieu d'un seul.

Lorsque le rendu stéréoscopique n’est pas pris en charge, la valeur renvoyée sera la cible par défaut. Cette fonctionnalité est prise en charge par tous les backends matériels, à l’exception de Metal, en combinaison avec ` QSurfaceFormat::StereoBuffers`, à condition qu’elle soit prise en charge par la pile des pilotes graphiques et d’affichage lors 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é créée avec succès pour la dernière fois. Utilisez cette fonction pour déterminer s'il est nécessaire d'appeler à nouveau ` createOrResize()` : si ` currentPixelSize() != surfacePixelSize() `, cela signifie que la chaîne d'échange doit être redimensionnée.

Bien que, dans de nombreux cas, la valeur soit identique à celle renvoyée par ` QWindow::size() * QWindow::devicePixelRatio()`, il n’est pas garanti que la taille indiquée par ` QWindow` soit correcte sur toutes les plateformes et dans toutes les implémentations d’API graphiques. L’utilisation de cette fonction est donc fortement recommandée 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 d’éventuels conflits d’accès lorsque la fonction QRhi est utilisée sur un thread de rendu dédié, car cela évite d’avoir à appeler des fonctions QWindow, qui pourraient alors accéder à des données mises à jour sur le thread principal.

Voir également surfacePixelSize().

QRhiRenderBuffer *QRhiSwapChain::depthStencil() const

Renvoie le tampon de rendu actuellement associé à la profondeur-stencil.

Voir également setDepthStencil().

QRhiSwapChain::Flags QRhiSwapChain::flags() const

Renvoie les indicateurs actuellement activés.

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 relatives à l'écran associé.

Ne partez pas du principe que cette opération est peu coûteuse. Selon la plate-forme, cette fonction effectue diverses requêtes qui peuvent avoir un impact sur les performances.

Voir également QRhiSwapChainHdrInfo.

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

Renvoie « true » si le format de swapchain indiqué ( f ) est pris en charge. Le format SDR est toujours pris en charge.

Cette fonction sert principalement à être appelée avant le premier appel à ` createOrResize()` une fois que la fenêtre est déjà définie. Cela permet aux backends ` QRhi ` d’effectuer des requêtes spécifiques à la plateforme ou au système de fenêtrage afin de 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 pris en charge, appelez ` setFormat()` pour définir le format demandé, puis appelez ` createOrResize()`. Soyez toutefois conscient des conséquences : la demande réussie d’un format HDR impliquera de gérer un espace colorimétrique différent, éventuellement d’effectuer une correction du niveau de blanc pour les contenus non compatibles HDR, d’ajuster les méthodes de mappage de tons, de modifier les paramètres de la cible de rendu hors écran, etc.

Voir également setFormat().

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

Renvoie un nouvel objet ` QRhiRenderPassDescriptor ` compatible avec cette chaîne d'échange.

La valeur renvoyée est utilisée de deux manières : elle peut être transmise aux fonctions ` 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 pouvant être affecté par la fonction ` flags()`. Un ` QRhiGraphicsPipeline ` ne peut être utilisé qu’en combinaison avec une chaîne d’échange pour laquelle le paramètre ` compatible ` QRhiRenderPassDescriptor est défini.

Voir également createOrResize().

QRhiSwapChainProxyData QRhiSwapChain::proxyData() const

Renvoie les données de proxy actuellement définies.

Voir également 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. La valeur 1 signifie qu'il n'y a pas d'anticrénelage par échantillonnage multiple.

Voir également la fonction ` setSampleCount()`.

void QRhiSwapChain::setDepthStencil(QRhiRenderBuffer *ds)

Définit l’ ds du tampon de rendu pour qu’il soit utilisé comme tampon de profondeur-stencil.

Voir également depthStencil().

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

Définit les indicateurs « f ».

Voir aussi flags().

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

Définit le format f.

Évitez de définir des formats signalés comme non pris en charge par la fonction ` 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 d'activer la sortie HDR dans les paramètres d'affichage.

Consultez isFormatSupported(), QRhiSwapChainHdrInfo et Format pour plus d’informations sur la sortie à plage dynamique élevée.

Voir également format().

void QRhiSwapChain::setProxyData(const QRhiSwapChainProxyData &d)

Définit l'd des données du proxy.

Voir également proxyData() et QRhi::updateSwapChainProxyData().

void QRhiSwapChain::setRenderPassDescriptor(QRhiRenderPassDescriptor *desc)

Partenaire de l'QRhiRenderPassDescriptor desc .

Voir également renderPassDescriptor().

void QRhiSwapChain::setSampleCount(int samples)

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

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

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

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

Lorsque la fonction ` QRhiCommandBuffer::setShadingRate()` est également appelée, c’est le taux d’ombrage le plus élevé des deux qui est utilisé pour chaque tuile. Il n’existe actuellement aucun moyen de contrôler le comportement du combinateur.

Cette fonction a été introduite dans Qt 6.9.

Voir également shadingRateMap().

void QRhiSwapChain::setWindow(QWindow *window)

Définit la propriété « window ».

Voir aussi window().

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

Renvoie la valeur actuellement définie pour ` QRhiShadingRateMap`. Par défaut, cette valeur est ` nullptr`.

Cette fonction a été introduite dans Qt 6.9.

Voir également 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 sélectionnée.

Voir aussi setWindow().