Rendu instancié

Introduction

Qt Quick 3D prend en charge l'instanciation des objets Model. L'instanciation fait référence à une technique dans laquelle un objet est rendu plusieurs fois avec un seul appel de dessin. (Par exemple, la fonction OpenGL glDrawElementsInstanced.)

L'instanciation permet de dupliquer un modèle avec des variations. Contrairement à l'utilisation d'un site Repeater3D, le modèle et ses ressources graphiques ne sont alloués qu'une seule fois. Le rendu des instances dupliquées est effectué à bas niveau par le GPU. En fonction de la complexité du modèle, cela peut améliorer les performances de plusieurs ordres de grandeur.

En pratique, l'instanciation est réalisée en définissant une table qui spécifie comment chaque instance est modifiée par rapport au modèle de base.

API d'instanciation

Le principe fondamental de l'API d'instanciation est qu'elle est explicite : Elle n'essaie pas de détecter automatiquement les possibilités d'instanciation dans l'API existante. Au lieu de cela, chaque modèle est marqué individuellement en définissant sa propriété instancing pour qu'elle fasse référence à un objet Instancing. Le même objet d'instanciation peut être utilisé sur plusieurs modèles à la fois.

L'objet Instancing spécifie une table qui définit comment chaque copie est rendue. Les modifications disponibles sont les suivantes

• transformation: position, rotation et échelle
• couleur: une couleur qui est mélangée avec le matériau du modèle
• données personnalisées: données pouvant être utilisées par les matériaux personnalisés.

Qt fournit trois types QML qui héritent d'Instancing :

• InstanceList énumère toutes les instances et permet de lier les propriétés de chaque instance.
• RandomInstancing permet de tester et de prototyper rapidement en générant des instances aléatoires dans des limites définies.
• FileInstancing lit une table d'instances à partir d'un fichier externe.

L'exemple d'instanciation montre comment créer une scène à l'aide de l'API QML.

D'autres types de tables d'instance peuvent être définis en C++ en sous-classant QQuick3DInstancing. Par exemple, le site particle system utilise sa propre table d'instance en interne. Elle est disponible à l'adresse ModelParticle3D.instanceTable.

En écrivant un code de nuanceur personnalisé, il est possible d'utiliser l'instanciation pour contrôler des propriétés supplémentaires, telles que des variables pour le rendu basé sur la physique, les poids d'animation du squelette, la distorsion, ou tout ce qui peut être exprimé avec des matériaux personnalisés. Les données personnalisées de la table d'instanciation sont constituées de quatre nombres à virgule flottante.

L'exemple d'instanciation personnalisée montre comment combiner des matériaux personnalisés et une table d'instance implémentée en C++.

Mélange alpha et instanciation

Pour que l'alpha blending soit correct, il faut que les objets semi-transparents soient rendus d'avant en arrière. C'est pourquoi QtQuick3D trie les objets opaques et semi-transparents séparément et les rend dans l'ordre correct. Avec l'instanciation, cependant, le GPU rendra les instances dans l'ordre spécifié par la table d'instanciation, si depth-sorting n'est pas activé. Pour des raisons de performances, QtQuick3D ne trie pas la table par défaut, car cela peut prendre beaucoup de temps avec un grand nombre d'instances. Cela signifie que si des instances semi-transparentes se chevauchent entre elles ou avec d'autres objets semi-transparents, les résultats peuvent être erronés. En général, l'erreur est moins visible lorsque l'opacité est faible.

Les objets entièrement opaques ainsi que les objets semi-transparents qui ne se chevauchent pas seront toujours rendus correctement, puisque Qt Test utilise le test du tampon de profondeur pour éviter de dessiner derrière les objets opaques. Cependant, l'absence de tri a des conséquences potentielles sur les performances des objets opaques : Ils peuvent ne pas être rendus dans l'ordre optimal, ce qui signifie que le même pixel peut être écrit plusieurs fois, ce qui donne plus de travail au nuanceur de fragment.

Le moteur de rendu n'inspecte pas le contenu de la table d'instanciation, qui doit donc être spécifiée explicitement lorsqu'une table d'instance contient des valeurs alpha semi-transparentes : Définissez la propriété hasTransparency sur true pour vous assurer que le moteur de rendu active le mélange alpha. Cela s'applique à toutes les instances : Même les instances totalement opaques seront rendues sans test de profondeur, ce qui peut entraîner des erreurs visibles.

L'ordre de rendu par rapport au reste de la scène peut être ajusté en définissant l'adresse depth bias du modèle.

Transformations et instanciation

Chaque instance possède sa propre transformation dans la table d'instance. Celle-ci est combinée avec les transformations du modèle instancié. C'est un peu complexe, car il y a plusieurs cas d'utilisation :

• Effectuer une transformation sur le modèle qui est appliquée à chaque instance individuelle. Cela permet de réaliser des animations bon marché, par exemple en faisant pivoter toutes les instances en même temps sans devoir modifier la table des instances.
• Transformer tout le groupe d'instances en une seule fois.
• Instancier une hiérarchie de modèles.

Pour prendre en charge tous ces cas, la transformation du modèle est divisée en deux parties : la transformation de l'instance locale et la transformation de l'instance globale. D'un point de vue conceptuel, l'instanciation s'effectue de la manière suivante :

• Le modèle est d'abord transformé selon la transformation d'instance locale.
• Ensuite, chaque instance est calculée en appliquant la transformation de la table d'instance
• Enfin, l'ensemble du groupe d'objets instanciés est transformé selon la transformation d'instance globale.

Par défaut, la transformation d'instance locale d'un modèle se compose de l'échelle et de la rotation du modèle, tandis que le reste est intégré à la transformation d'instance globale.

Ceci peut être contrôlé en définissant la propriété instanceRoot du modèle. Celle-ci définit l'origine du système de coordonnées de l'instance. L'utilisation la plus courante est l'instanciation d'une hiérarchie de modèles. Par exemple, une sphère en orbite autour d'un cube :

Model {
    id: cube
    instancing: someInstanceTable
    source: "#Cube"
    materials: DefaultMaterial { diffuseColor: "lightgray" }
    Node {
        Model {
            source: "#Sphere"
            instanceRoot: cube
            instancing: cube.instancing
            x: 150
            materials: DefaultMaterial { diffuseColor: "gray" }
        }
        NumberAnimation on eulerRotation.y {
            from: 0
            to: 360
            duration: 4000
            loops: Animation.Infinite
        }
    }
}

La propriété instanceRoot est nécessaire pour spécifier que l'instance de la sphère doit être positionnée comme si elle était un élément du cube. Chaque modèle d'une hiérarchie doit encore spécifier la propriété instancing: dans des cas normaux, ils doivent tous être définis sur le même objet Instancing.

instanceRoot peut également être utilisée lors de l'instanciation d'un modèle unique. Par exemple, un cylindre tournant autour d'un point décentré :

 Node {
    id: parentNode
    Model {
        source: "#Cylinder"
        instanceRoot: parentNode
        instancing: anotherInstanceTable
        x: 25
        materials: DefaultMaterial { diffuseColor: "white" }
    }
    NumberAnimation on eulerRotation.y {
        from: 0
        to: 360
        duration: 1000
        loops: Animation.Infinite
    }
}

Sélection et instanciation

Picking est un mécanisme qui permet de sélectionner un modèle à partir d'une interaction avec l'interface utilisateur. Avec le rendu instancié, il existe plusieurs représentations du même modèle, de sorte que le résultat de la sélection comprendra une adresse instance index. La sélection instanciée est activée en définissant la propriété pickable sur le modèle de base.