Qt Quick Architecture 3D

Qt Quick 3D étend Qt Quick pour prendre en charge le rendu de contenu 3D. Il ajoute des fonctionnalités étendues, notamment plusieurs nouvelles importations QML publiques, ainsi qu'un nouveau graphe de scène interne et un nouveau moteur de rendu. Ce document décrit l'architecture de Qt Quick 3D, de l'API publique aux détails du fonctionnement du pipeline de rendu.

Vue d'ensemble des modules

Qt Quick 3D se compose de plusieurs modules et plugins qui exposent les API 3D supplémentaires ainsi que des utilitaires pour le conditionnement et l'importation de ressources 3D existantes.

Importations QML

• QtQuick3D - L'import principal qui contient tous les composants de base de Qt Quick 3D
• QtQuick3D.AssetUtils - Une bibliothèque pour l'importation de ressources 3D au moment de l'exécution.
• QtQuick3D.Helpers - Une bibliothèque de composants supplémentaires qui peuvent être utilisés pour aider à concevoir des scènes 3D et à les déboguer.

Bibliothèques C

• QtQuick3D - Le seul module C++ public. Contient les définitions de tous les types exposés à l'importation QML de QtQuick3D ainsi que quelques API C
  • QQuick3DGeometry - Sous-classe pour créer des données de maillage procédurales
  • QQuick3DTextureData - Sous-classe pour créer des données de texture procédurales
  • QQuick3D::idealSurfaceFormat - utilisé pour obtenir le format de surface idéal
• QtQuick3DAssetImport - Une bibliothèque interne et privée pour faciliter l'importation d'actifs et la conversion d'actifs en QML.
• QtQuick3DRuntimeRender - Une bibliothèque interne et privée qui contient les nœuds du graphe de la scène spatiale et le moteur de rendu.
• QtQuick3DUtils - Une bibliothèque interne et privée utilisée comme bibliothèque utilitaire commune par tous les autres modules C++.

Plugins AssetImporters

L'outil d'importation d'actifs est implémenté à l'aide d'une architecture basée sur des plugins. Les plugins fournis avec Qt Quick 3D étendent les fonctionnalités de la bibliothèque et de l'outil d'importation d'actifs, Balsam.

• Assimp - Ce plugin utilise la bibliothèque tierce libAssimp pour convertir les ressources 3D dans les formats d'échange 3D en composants QML de Qt Quick 3D.

Comment Qt Quick 3D s'intègre-t-il dans la pile graphique de Qt 3D ?

Qt Quick 3D" src="images/quick3d-graphics-stack.drawio.svg" title="Schéma de l'architecture de la pile graphique Qt Quick 3D"/>

Le diagramme ci-dessus illustre la façon dont Qt Quick 3D s'intègre dans la pile graphique Qt. Qt Quick 3D fonctionne comme une extension de l'API 2D Qt Quick, et lors de l'utilisation d'éléments de scène 3D en conjonction avec View3D, la scène sera rendue via l'interface matérielle de rendu Qt (RHI). La RHI traduit les appels d'API en appels d'API de matériel de rendu natif corrects pour une plate-forme donnée. Le diagramme ci-dessus montre les options disponibles pour chaque plateforme. Si aucun backend natif n'est explicitement défini, Qt Quick utilisera par défaut un backend natif sensible pour le rendu pour chaque plateforme.

L'intégration entre les composants 3D de la pile Qt Quick et la pile Qt Quick est décrite dans les sections suivantes.

Intégration 3D en 2D

L'affichage de contenu 3D en 2D est l'objectif principal de l'API 3D de Qt Quick. L'interface principale pour l'intégration de contenu 3D en 2D est le composant View3D.

Le composant View3D fonctionne comme toute autre classe dérivée de QQuickItem avec du contenu et implémente la fonction virtuelle QQuickItem::updatePaintNode. Qt Quick appelle updatePaintNode pour tous les éléments "sales" de la scène Qt Quick pendant la phase de synchronisation. Cela inclut les éléments 3D gérés par View3D, qui subissent également leur phase de synchronisation à la suite de l'appel à updatePaintNode.

La méthode updatePaintNode de View3D effectue les actions suivantes :

• Configurer un moteur de rendu et une cible de rendu s'il n'en existe pas déjà une
• Synchronisation des éléments de la scène 3D via le SceneManager
• Mettre à jour toutes les textures "dynamiques" qui ont été rendues par Qt Quick (2D dans le chemin des textures 3D ci-dessous).

Le rendu de la scène 3D n'a cependant pas lieu dans la méthode View3D updatePaintNode. Au lieu de cela, updatePaintNode renvoie une sous-classe de QSGNode contenant le moteur de rendu de Qt Quick 3D, qui rendra la scène 3D pendant la phase de prétraitement du processus de rendu de Qt Quick.

Le rendu de Qt Quick 3D dépend de l'application View3D::renderMode utilisée :

Hors écran

Le mode par défaut de View3D est Offscreen. En mode hors écran, View3D devient un fournisseur de texture en créant une surface hors écran et en effectuant le rendu sur cette surface. Cette surface peut être mappée en tant que texture dans Qt Quick et rendue avec QSGSimpleTextureNode.

Ce modèle est très proche de la manière dont les QSGLayerNodes fonctionnent déjà dans Qt Quick.

Sous-couche

Lors de l'utilisation du mode Underlay, la scène 3D est directement rendue sur le site QQuickWindow contenant le site View3D. Le rendu se produit à la suite du signal QQuickWindow::beforeRenderPassRecording(), ce qui signifie que tout ce qui se trouve sur le site Qt Quick sera rendu par-dessus le contenu 3D.

Superposition

Lorsque le mode Overlay est utilisé, la scène 3D est directement rendue sur le site QQuickWindow contenant le site View3D. Le rendu est effectué à l'aide du signal QQuickWindow::afterRenderPassRecording(), ce qui signifie que le contenu 3D sera rendu au-dessus de tout autre contenu du site Qt Quick.

En ligne

Le mode de rendu Inline utilise QSGRenderNode, qui permet un rendu direct vers la cible de rendu de Qt Quick sans utiliser de surface hors écran. Pour ce faire, il injecte les commandes de rendu en ligne pendant le rendu 2D de la scène Qt Quick.

Ce mode peut être problématique car il utilise le même tampon de profondeur que le moteur de rendu Qt Quick, et les valeurs z ont une signification complètement différente dans Qt Quick et Qt Quick 3D.

Intégration 2D dans 3D

Lors du rendu d'une scène 3D, il existe de nombreux scénarios dans lesquels il est nécessaire d'intégrer des éléments 2D dans la 3D. Il existe deux façons différentes d'intégrer du contenu 2D dans des scènes 3D, chacune ayant son propre chemin pour arriver à l'écran.

Chemin direct

Le chemin direct est utilisé pour rendre le contenu 2D Qt Quick comme s'il existait en tant qu'élément plat dans la scène 3D. Prenons par exemple la définition de scène suivante :

Node {
    Text {
        text: "Hello world!"
    }
}

Voici ce qui se passe : lorsqu'un composant enfant est défini sur un nœud spatial de type QQuickItem, il est d'abord enveloppé par un QQuick3DItem2D, qui est simplement un conteneur qui ajoute des coordonnées 3D à un élément 2D. Cela permet de définir la transformation 3D de base pour le rendu de tous les autres éléments 2D afin qu'ils apparaissent correctement dans la scène 3D.

Au moment du rendu de la scène, les QSGNodes de ces éléments 2D sont transmis au moteur de rendu Qt Quick pour générer les commandes de rendu appropriées. Comme les commandes sont effectuées en ligne et prennent en compte la transformation 3D actuelle, le rendu est exactement le même que dans le moteur de rendu 2D, mais s'affiche comme s'il avait été effectué en 3D.

L'inconvénient de cette approche est qu'aucune information sur l'éclairage de la scène 3D ne peut être utilisée pour ombrer le contenu 2D, car le moteur de rendu 2D Qt Quick n'a aucune notion d'éclairage.

Chemin de texture

Le chemin de texture utilise une scène 2D Qt Quick pour créer un contenu de texture dynamique. Considérons la définition de texture suivante :

Texture {
    sourceItem: Item {
        width: 256
        height: 256
        Text {
            anchors.centerIn: parent
            text: "Hello World!"
        }
    }
}

Cette approche fonctionne de la même manière que les éléments de calque dans Qt Quick, en ce sens que tout est rendu sur une surface hors écran de la taille de l'élément de niveau supérieur, et que cette surface hors écran est ensuite utilisable en tant que texture pouvant être réutilisée ailleurs.

Cette texture peut ensuite être utilisée par les matériaux de la scène pour rendre le contenu de Qt Quick sur les éléments.

Synchronisation de la scène

Gestionnaire de scène

Le gestionnaire de scène de Qt Quick 3D est chargé de suivre les éléments spatiaux d'une scène 3D et de s'assurer que les éléments mettent à jour leurs nœuds de graphe de scène correspondants au cours de la phase de synchronisation. Dans Qt Quick, ce rôle est assumé par QQuickWindow pour le cas 2D. Le gestionnaire de scène est l'interface principale entre les nœuds frontaux et les objets du graphe de scène dorsal.

Chaque élément View3D aura au moins un gestionnaire de scène, car un gestionnaire est créé et associé à la racine de la scène intégrée lors de la construction. Lorsque des nœuds spatiaux sont ajoutés en tant qu'enfants de View3D, ils sont enregistrés auprès du gestionnaire de scène de View3D. Lors de l'utilisation d'une scène importée, un second SceneManager est créé (ou référencé s'il existe déjà) pour gérer les nœuds qui ne sont pas des enfants directs de View3D. Cela est nécessaire car, contrairement à View3D, une scène importée n'existe pas sur QQuickWindow tant qu'elle n'est pas référencée. Le gestionnaire de scène supplémentaire veille à ce que les ressources appartenant à la scène importée soient créées au moins une fois par QQuickWindow dans lequel elles sont référencées.

Bien que le gestionnaire de scène soit une API interne, il est important de savoir qu'il est responsable de l'appel de updateSpatialNode sur tous les objets qui ont été marqués comme sales en appelant la méthode update().

Synchronisation frontend/backend

L'objectif de la synchronisation est de s'assurer que les états définis sur le frontend (Qt Quick) correspondent à ceux définis sur le backend (Qt Quick Spatial Scene Graph Renderer). Par défaut, le frontend et le backend vivent dans des threads séparés : le frontend dans le thread principal de Qt XML, et le backend dans le thread de rendu de Qt Quick. La phase de synchronisation est le moment où le thread principal et le thread de rendu peuvent échanger des données en toute sécurité. Au cours de cette phase, le gestionnaire de scène appelle updateSpatialNode pour chaque nœud sale de la scène. Cela permet de créer un nouveau nœud backend ou de mettre à jour un nœud existant pour qu'il soit utilisé par le moteur de rendu.

Qt Quick Graphique spatial de la scène

Qt Quick 3D est conçu pour utiliser le même modèle de séparation frontend/backend que Qt Quick: les objets frontend sont contrôlés par le moteur Qt Quick, tandis que les objets backend contiennent des données d'état pour le rendu de la scène. Les objets frontaux héritent de QObject et sont exposés au moteur Qt Quick. Les éléments des fichiers source QML correspondent directement aux objets frontaux.

Lorsque les propriétés de ces objets frontaux sont mises à jour, un ou plusieurs nœuds backend sont créés et placés dans un graphe de scène. Étant donné que le rendu de scènes 3D implique beaucoup plus d'état que le rendu 2D, il existe un ensemble distinct de nœuds de graphe de scène spécialisés pour représenter l'état des objets de la scène 3D. Ce graphe de scène est connu sous le nom de Qt Quick Spatial Scene Graph.

Les objets frontaux et les nœuds dorsaux peuvent être classés en deux catégories. Les premiers sont spatiaux, en ce sens qu'ils existent quelque part dans l'espace 3D. En pratique, cela signifie que chacun de ces types contient une matrice de transformation. Pour les éléments spatiaux, la relation parent-enfant est importante car chaque élément enfant hérite de la transformation de ses parents.

L'autre catégorie d'éléments est celle des ressources. Les éléments de ressources n'ont pas de position dans l'espace 3D, mais sont simplement des états utilisés par d'autres éléments. Il peut y avoir une relation parent-enfant entre ces éléments, mais elle n'a pas d'autre signification que la propriété.

Contrairement au graphe de scène 2D de Qt Quick, le graphe de scène spatial expose directement les nœuds de ressources à l'utilisateur. Ainsi, par exemple, dans Qt Quick, alors que QSGTexture est une API publique, il n'y a pas de QQuickItem qui expose cet objet directement. Au lieu de cela, l'utilisateur doit soit utiliser un élément Image, qui décrit à la fois l'origine de la texture et la manière de la rendre, soit écrire un code C++ pour opérer sur le site QSGTexture lui-même. Dans Qt Quick 3D, ces ressources sont exposées directement dans l'API QML. Cela est nécessaire car les ressources constituent une partie importante de l'état de la scène. Ces ressources peuvent être référencées par de nombreux objets de la scène : par exemple, plusieurs matériaux peuvent utiliser la même texture. Il est également possible de définir les propriétés d'une texture au moment de l'exécution, ce qui modifierait directement la manière dont une texture est échantillonnée, par exemple.

Objets spatiaux

Tous les objets spatiaux sont des sous-classes du composant Node, qui contient les propriétés définissant la position, la rotation et l'échelle dans l'espace 3D.

• Node
• Light
  • DirectionalLight
  • PointLight
  • SpotLight
• Camera
  • PerspectiveCamera
  • OrthographicCamera
  • FrustumCamera
  • CustomCamera
• Model
• Loader3D
• Repeater3D
• Skeleton
• Joint

Objets ressources

Les objets de ressource sont des sous-classes du composant Object3D. Object3D n'est qu'une sous-classe de QObject avec quelques aides spéciales à utiliser avec le gestionnaire de scène. Les objets ressources ont des associations parent/enfant, mais celles-ci sont surtout utiles pour la propriété des ressources.

• Texture
• TextureData
• Geometry
• Material
  • Matériau par défaut
  • PrincipledMaterial
  • CustomMaterial
• Effect
• SceneEnvironment

View3D et couches de rendu

En ce qui concerne la séparation entre le front-end et le back-end, View3D est le point de séparation du point de vue de l'utilisateur, car c'est View3D qui définit le contenu de la scène à rendre. Dans le graphique de scène spatiale Qt Quick, le nœud racine d'une scène qui sera rendue est un nœud de couche. Les nœuds de couche sont créés par View3D à l'aide d'une combinaison des propriétés de View3D et de SceneEnvironment. Lors du rendu d'une scène pour View3D, c'est ce nœud de couche qui est transmis au moteur de rendu pour rendre la scène.

Rendu de la scène

Configuration de la cible de rendu

La première étape du processus de rendu consiste à déterminer et à configurer la cible de rendu de la scène. En fonction des propriétés définies dans le site SceneEnvironment, la cible de rendu réelle variera. La première décision est de savoir si le contenu est rendu directement sur la surface d'une fenêtre ou sur une texture hors écran. Par défaut, View3D effectue le rendu sur une texture hors écran. Lors de l'utilisation d'effets de post-traitement, le rendu vers une texture hors écran est obligatoire.

Une fois que la cible de rendu de la scène est déterminée, certains états globaux sont définis.

• taille de la fenêtre - si le rendu se fait sur une fenêtre
• viewport - la taille de la zone de la scène en cours de rendu
• scissor rect - le sous-ensemble d'une fenêtre sur lequel la fenêtre de visualisation doit être découpée
• clear color - la couleur avec laquelle il faut effacer la cible de rendu, le cas échéant.

Préparation du rendu

L'étape suivante du rendu est l'étape de préparation, au cours de laquelle le moteur de rendu fait le ménage pour déterminer ce qui doit être rendu pour une image donnée, et s'assurer que toutes les ressources nécessaires sont disponibles et à jour.

L'étape de préparation elle-même comporte deux phases : la préparation de haut niveau, qui consiste à déterminer ce qui doit être rendu et les ressources nécessaires, et la préparation de bas niveau, qui utilise RHI pour configurer les pipelines de rendu et les tampons, ainsi que les dépendances de rendu de la passe de scène principale.

Préparation du rendu de haut niveau

L'objectif de cette phase est d'extraire l'état du graphe de la scène spatiale afin de l'utiliser pour créer des commandes de rendu. En résumé, le moteur de rendu crée des listes de combinaisons de géométrie et de matériaux pour effectuer le rendu à partir d'une seule caméra et d'un ensemble d'états d'éclairage.

La première chose à faire est de déterminer l'état global commun à tout le contenu. Si SceneEnvironment définit un lightProbe, il vérifie si la carte d'environnement associée à cette texture de sonde lumineuse est chargée, et si ce n'est pas le cas, une nouvelle carte d'environnement est chargée ou générée. La génération d'un environnement sera elle-même un ensemble de passes pour convoluer la texture source en une carte cubique. Cette carte contiendra à la fois des informations sur la réflexion spéculaire et sur l'irradiance, qui sont utilisées pour l'ombrage des matériaux.

Ensuite, le moteur de rendu doit déterminer la caméra à utiliser dans la scène. Si une caméra active n'est pas explicitement définie par View3D, la première caméra disponible dans la scène est utilisée. S'il n'y a pas de caméra dans la scène, aucun contenu n'est rendu et le moteur de rendu s'arrête.

Une fois la caméra déterminée, il est possible de calculer la matrice de projection pour cette image. Le calcul est effectué à ce stade car chaque élément de rendu doit savoir comment être projeté. Cela signifie également qu'il est maintenant possible de calculer quels éléments de rendu doivent être rendus. En commençant par la liste de tous les éléments pouvant être rendus, nous supprimons tous les éléments qui ne sont pas visibles parce qu'ils sont soit désactivés, soit complètement transparents. Ensuite, si le frustum culling est activé sur la caméra active, chaque élément à rendre est vérifié pour voir s'il est complètement en dehors de la vue du frustum de la caméra, et si c'est le cas, il est supprimé de la liste des éléments à rendre.

En plus de la projection de la caméra, la direction de la caméra est également calculée car elle est nécessaire pour les calculs d'éclairage dans le code d'ombrage.

S'il y a des nœuds de lumière dans la scène, ils sont alors rassemblés dans une liste de la longueur du maximum de lumières disponibles. S'il y a plus de nœuds de lumière dans la scène que le nombre de lumières pris en charge par le moteur de rendu, tous les nœuds de lumière supplémentaires au-delà de cette limite sont ignorés et ne contribuent pas à l'éclairage de la scène. Il est possible de spécifier la portée des nœuds de lumière, mais notez que même en définissant une portée, l'état d'éclairage de chaque lumière est toujours envoyé à tous les matériaux qui ont un éclairage, mais pour les lumières qui ne sont pas dans la portée, la luminosité sera fixée à 0, donc en pratique ces lumières ne contribueront pas à l'éclairage de ces matériaux.

Maintenant que la liste des objets à rendre est plus courte, chacun de ces éléments doit être mis à jour pour refléter l'état actuel de la scène. Pour chaque objet de rendu, nous vérifions qu'un matériau approprié est chargé, et si ce n'est pas le cas, un nouveau matériau est créé. Un matériau est une combinaison de shaders et d'un pipeline de rendu, et il est nécessaire pour créer un appel de dessin. En outre, le moteur de rendu s'assure que toutes les ressources nécessaires au rendu d'un objet à rendre sont chargées, par exemple la géométrie et les textures définies sur le modèle. Les ressources qui ne sont pas déjà chargées le sont ici.

Voir Mise en cache sur disque des shaders pour une discussion sur la mise en cache sur disque des shaders pour les matériaux et les effets.

La liste des éléments à rendre est ensuite triée en trois listes.

• Éléments opaques : ils sont triés de l'avant vers l'arrière ou, en d'autres termes, des éléments les plus proches de la caméra aux éléments les plus éloignés de la caméra. Cela permet de tirer parti de l'élimination des occlusions matérielles ou de la détection précoce des z dans le nuanceur de fragment.
• Éléments 2D : il s'agit des éléments QtQuick qui sont rendus par le moteur de rendu Qt Quick.
• Éléments transparents : ils sont triés de l'arrière vers l'avant ou, en d'autres termes, des éléments les plus éloignés de la caméra aux éléments les plus proches de la caméra. En effet, les éléments transparents doivent être mélangés avec tous les éléments qui se trouvent derrière eux.

Préparation du rendu à bas niveau

Maintenant que tout ce qui doit être pris en compte pour cette image a été déterminé, la plomberie et les dépendances pour la passe de rendu principale peuvent être abordées. La première chose à faire dans cette phase est d'effectuer le rendu de toutes les passes préliminaires nécessaires à la passe principale.

• Rendu de la passe de profondeur - Certaines fonctions telles que l'occlusion ambiante de l'espace écran et l'ombrage nécessitent une passe de profondeur préalable. Cette passe consiste à rendre tous les éléments opaques dans une texture de profondeur.
• Rendu SSAOPass - L'objectif de la passe Screen Space Ambient Occlusion est de générer une texture d'occlusion ambiante. Cette texture est utilisée ultérieurement par les matériaux pour assombrir certaines zones lors de l'ombrage.
• Rendu des passes d'ombre - Chaque lumière de la scène dont l'ombre est activée contribue à une passe d'ombre supplémentaire. Il existe deux techniques d'ombrage différentes employées par le moteur de rendu, de sorte qu'en fonction du type de lumière, il y aura des passes différentes. Lors du rendu des ombres d'une lumière directionnelle, la scène est rendue dans une texture d'occlusion 2D à partir d'une combinaison de la direction de la lumière directionnelle et de la taille du frustum de la caméra. Lors du rendu d'ombres provenant d'une lumière ponctuelle, la texture d'occlusion de la lumière est une carte cubique représentant la contribution de l'occlusion par rapport à chaque direction de la lumière.
• Render ScreenTexture - Cette passe ne se produit que lors de l'utilisation d'un site CustomMaterial qui nécessite une texture d'écran, qui peut être utilisée pour des techniques de rendu telles que la réfraction. Cette passe fonctionne comme une passe de profondeur, mais rend tous les éléments opaques dans une texture de couleur.

Une fois les rendus de dépendance effectués, les autres passes sont préparées mais non rendues. Cette préparation consiste à prendre l'état recueilli lors de l'étape de préparation de haut niveau et à le traduire en primitives graphiques telles que la création/mise à jour des valeurs des tampons uniformes, l'association des échantillonneurs avec les textures de dépendance, la configuration des liens avec les ressources des shaders et tout ce qui est nécessaire à la création d'un état de pipeline pour effectuer un appel de dessin.

Rendu de la scène

Maintenant que le travail de préparation est terminé, la partie la plus facile est d'exécuter les commandes qui contribuent au contenu de la scène principale. Le rendu s'effectue dans l'ordre suivant :

• Clear Pass - Ce n'est pas vraiment une passe, mais en fonction du backgroundMode défini sur SceneEnvironment, différentes choses peuvent se produire ici. Si le mode d'arrière-plan est soit transparent, soit en couleur, le tampon de couleur sera effacé avec la transparence ou la couleur spécifiée. Cependant, si le mode d'arrière-plan est défini sur SkyBox, une passe sera exécutée pour rendre SkyBox du point de vue de la caméra, ce qui remplira également le tampon avec les données initiales.
• Passe Opaque - Ensuite, tous les éléments opaques seront dessinés. Il s'agit simplement de définir l'état du pipeline et d'exécuter la commande de dessin pour chaque élément dans l'ordre de la liste puisqu'ils sont déjà triés à ce stade.
• 2D Pass - S'il y a des éléments 2D dans la scène, le moteur de rendu Qt Quick est invoqué pour générer les commandes de rendu nécessaires au rendu de ces éléments.
• Passage transparent - Enfin, les éléments transparents de la scène sont rendus un par un de la même manière que les éléments opaques.

Ceci conclut le rendu de la scène.

Post-traitement

Si une fonctionnalité de post-traitement est activée, on peut supposer que le résultat du moteur de rendu de la scène est une texture qui sert d'entrée à la phase de post-traitement. Toutes les méthodes de post-traitement sont des passes supplémentaires qui opèrent sur cette texture d'entrée de scène.

Toutes les étapes de la phase de post-traitement sont facultatives et si aucune fonction intégrée ni aucun effet défini par l'utilisateur n'est activé, le résultat du rendu de scène est utilisé par la cible de rendu finale. Notez cependant que tonemapping est activé par défaut.

Post-traitement intégré

ExtendedSceneEnvironment et son type parent SceneEnvironment offrent les effets les plus courants utilisés dans les scènes 3D, ainsi que la cartographie des tons qui est utilisée pour mapper les valeurs de couleur de la gamme dynamique élevée générées par le moteur de rendu à la gamme LDR 0-1. Les effets comprennent la profondeur de champ, l'éclat/la luminosité, le reflet de l'objectif, la vignette, l'ajustement et l'étalonnage des couleurs, le brouillard et l'occlusion ambiante.

Effets de post-traitement

Les applications peuvent spécifier leurs propres effets de post-traitement personnalisés sous la forme d'une liste ordonnée dans la propriété SceneEnvironment::effects. Lorsque cette liste est non vide, les effets qu'elle contient sont appliqués avant les effets intégrés fournis par ExtendedSceneEnvironment. Chaque effet de post-traitement fait partie d'une chaîne telle que la sortie de l'effet précédent est l'entrée de l'effet suivant. Le premier effet de cette chaîne reçoit son entrée directement de la sortie de l'étape de rendu de la scène. Il est également possible pour les effets d'accéder à la sortie de la texture de profondeur du moteur de rendu de scène.

Chaque effet de ce processus peut être composé de plusieurs sous-passes, ce qui signifie qu'il est possible de rendre le contenu dans des tampons intermédiaires. La dernière passe d'un effet à plusieurs passes devrait produire une texture unique contenant les données de couleur à utiliser dans les étapes suivantes de la phase de post-traitement.

Anticrénelage temporel et progressif

Les étapes d'anticrénelage temporel et progressif sont optionnellement activées en définissant des propriétés sur le site SceneEnvironment. Bien qu'elles ne fassent pas strictement partie de la phase de post-traitement, les résultats réels de l'anticrénelage temporel et progressif sont obtenus au cours de la phase de post-traitement.

L'anticrénelage temporel est exécuté lorsqu'une scène est activement mise à jour. Lorsqu'il est activé, la caméra active effectue de très petits ajustements de la direction de la caméra pour chaque image tout en dessinant la scène. L'image actuelle est ensuite mélangée à l'image rendue précédemment afin de lisser ce qui a été rendu.

L'anticrénelage progressif n'est effectué que lorsqu'une scène n'est pas mise à jour. Lorsqu'il est activé, une mise à jour est forcée et l'état actuel de la scène est rendu avec de très petits ajustements de la direction de la caméra active. Jusqu'à 8 images sont accumulées et mélangées avec des poids prédéfinis. Cela a pour effet de lisser une scène non animée, mais a un coût en termes de performances, car plusieurs images supplémentaires sont rendues à chaque mise à jour.

Anti-crénelage par super-échantillonnage (SSAA)

L'anticrénelage par super échantillonnage est un moyen brutal de lisser une scène. Il fonctionne en effectuant le rendu d'une texture qui est un multiple de la taille demandée pour la scène, puis en réduisant l'échantillonnage à la taille cible. Par exemple, si l'on demande un SSAA 2X, la scène sera rendue avec une texture deux fois plus grande que la taille souhaitée, puis sous-échantillonnée dans le cadre de cette phase. Cela peut avoir un impact considérable sur les performances et l'utilisation des ressources et doit donc être évité dans la mesure du possible. Il est également possible que la taille de View3D soit trop importante pour utiliser cette méthode, car la texture nécessaire pour cette méthode peut être plus grande que ce qui est pris en charge par le matériel de rendu.