Obsolete Members for Qt3DRender

Les membres suivants de la classe ` Qt3DRender ` sont obsolètes. Ils sont fournis afin de garantir la compatibilité avec l'ancien code source. Nous déconseillons fortement de les utiliser dans le nouveau code.

Espaces de noms

Classes

Espaces de noms

[deprecated] namespace Qt3DRender::Quick

Cet espace de noms est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] namespace Qt3DRender::Render

Cet espace de noms est obsolète. Nous vous déconseillons vivement de l'utiliser dans du nouveau code.

Classes

[deprecated] class Qt3DRender::QAbstractLight

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QAbstractRayCaster

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Qt3DRender::QAbstractRayCaster Il s'agit d'une classe de base abstraite permettant de projeter des rayons dans une scène 3D. Qt3DRender::QAbstractRayCaster ne peut pas être instanciée directement, mais uniquement via ses sous-classes. QAbstractRayCaster définit les propriétés communes à tous les projecteurs de rayons, telles que le mode d'exécution et la gestion des calques, tout en laissant aux sous-classes le soin de gérer les détails concrets de la projection des rayons.

Le lancer de rayons diffère du « picking » (qui utilise Qt3DRender::QObjectPicker) en ce qu’il ne nécessite pas d’événements de souris pour se déclencher.

Par défaut, les instances de ` Qt3DRender::QAbstractRayCaster ` sont désactivées. Lorsqu’elles sont activées, le rayon spécifié est testé à chaque image pour détecter les objets avec lesquels il entre en intersection. La propriété ` QAbstractRayCaster::hits ` est mise à jour avec les résultats du ray casting, même si aucun objet n’est trouvé.

L’ Qt3DRender::QPickingSettings permet de contrôler le ray casting, notamment en déterminant quelles primitives sont testées et comment les résultats sont renvoyés.

De plus, les composants de type « Qt3DRender::QLayer » peuvent être utilisés pour contrôler la manière dont les entités, ou les sous-graphes d’entités, réagissent au ray casting.

Voir également Qt3DRender::QRayCaster, Qt3DRender::QScreenRayCaster, Qt3DRender::QObjectPicker, Qt3DRender::QPickingSettings et Qt3DRender::QNoPicking.

[deprecated] class Qt3DRender::QAbstractTexture

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe QAbstractTexture ne doit pas être utilisée directement, mais plutôt via l'une de ses sous-classes. Chaque sous-classe implémente une cible de texture donnée (2D, 2DArray, 3D, CubeMap, etc.). Chaque sous-classe fournit un ensemble de foncteurs pour chaque couche, chaque face de cube map et chaque niveau de mipmap. À son tour, le backend utilise ces foncteurs pour remplir correctement de données la texture OpenGL correspondante. Le foncteur doit effectuer le moins de traitement possible afin de ne pas ralentir la génération et le chargement des textures. Si le contenu d’une texture est le résultat d’un processus de génération procédurale lent, il est recommandé de ne pas l’implémenter directement dans un foncteur.

Toutes les textures sont uniques. Si vous instanciez deux fois la même texture, cela créera deux textures identiques sur le GPU ; aucun partage n’aura lieu.

[deprecated] class Qt3DRender::QAbstractTextureImage

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Il convient d'utiliser QAbstractTextureImage pour fournir des données d'image à une classe QAbstractTexture. Elle contient les informations nécessaires : niveau de mipmap, couche, face du cube, qui chargent les données au bon endroit dans une texture OpenGL.

Les données proprement dites sont fournies via un ` QTextureImageDataGenerator ` qui sera exécuté par des tâches Aspect en arrière-plan. Il convient de créer une sous-classe de `QAbstractTextureImage` afin de fournir un foncteur et, le cas échéant, les propriétés supplémentaires nécessaires à ce dernier pour charger les données réelles.

[deprecated] class Qt3DRender::QAlphaCoverage

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe ` Qt3DRender::QAlphaCoverage ` active le mode de multisampling « alpha-to-coverage ». Lorsqu’il est activé, la valeur alpha du fragment est utilisée comme couverture pour l’échantillon et combinée à la valeur de couverture du fragment. La classe ` Qt3DRender::QAlphaCoverage ` n’a aucun effet si le multisampling est désactivé. Le mode « alpha-to-coverage » est particulièrement utile lorsqu’un mélange indépendant de l’ordre est requis, par exemple lors du rendu de feuilles, d’herbe et d’autres végétaux denses.

Elle peut être ajoutée à un ` QRenderPass ` en appelant ` QRenderPass::addRenderState()` :

QRenderPass *renderPass = new QRenderPass();

// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();

// Add the render states to the render pass
renderPass->addRenderState(alphaCoverage);
renderPass->addRenderState(multiSampleAntialiasing);

Ou à un « QRenderStateSet » en appelant QRenderStateSet::addRenderState() :

QRenderStateSet *renderStateSet = new QRenderStateSet();

// Create a alpha coverage render state
QAlphaCoverage *alphaCoverage = new QAlphaCoverage();
QMultiSampleAntiAliasing *multiSampleAntialiasing = new QMultiSampleAntiAliasing();

// Add the render states to the render state set
renderStateSet->addRenderState(alphaCoverage);
renderStateSet->addRenderState(multiSampleAntialiasing);

Voir également Qt3DRender::QMultiSampleAntiAliasing.

[deprecated] class Qt3DRender::QAlphaTest

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Comme l'explique la documentation OpenGL, le test alpha rejette un fragment en fonction du résultat d'une comparaison entre la valeur alpha du fragment entrant et une valeur de référence constante.

[deprecated] class Qt3DRender::QBlendEquation

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

L'équation de fusion sert à déterminer comment un nouveau pixel est combiné avec un pixel déjà présent dans le tampon d'image.

[deprecated] class Qt3DRender::QBlendEquationArguments

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

OpenGL antérieur à la version 3.0 : définit le même état de fusion pour tous les tampons de dessin (un QBlendEquationArguments). OpenGL 3.0 à 4.0 : Définit le même état de fusion pour tous les tampons de dessin, mais permet de désactiver la fusion pour certains tampons en particulier (un QBlendEquationArguments pour définir glBlendFunc, n QBlendEquationArguments pour activer/désactiver les tampons de dessin) OpenGL 4.0 et versions ultérieures : permet de définir l'état de fusion individuellement pour chaque tampon de dessin.

[deprecated] class Qt3DRender::QBlitFramebuffer

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du code nouveau.

Ce nœud insère un « glBlitFrameBuffer » ou un équivalent dans le flux de commandes. Cela offre une méthode plus efficace pour copier des rectangles entre des textures ou des tampons de surface encapsulés par QRenderTarget que de dessiner des quadrilatères texturés. Il prend également en charge la mise à l'échelle avec la méthode d'interpolation spécifiée.

[deprecated] class Qt3DRender::QBufferCapture

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QCamera

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QCameraLens

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QCameraSelector

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un objet ` Qt3DRender::QCameraSelector ` peut être utilisé pour sélectionner la caméra, qui est utilisée par le `FrameGraph` lors du dessin des entités.

[deprecated] class Qt3DRender::QClearBuffers

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un nœud FrameGraph de type « Qt3DRender::QClearBuffers » permet d'effacer les tampons de destination de rendu spécifiques avec des valeurs précises.

[deprecated] class Qt3DRender::QClipPlane

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Par défaut, OpenGL prend en charge jusqu'à 8 plans de découpe supplémentaires. Qt3DCore::QClipPlane permet d'activer l'un de ces plans supplémentaires. Ces plans peuvent ensuite être manipulés dans les shaders à l'aide de gl_ClipDistance[i], où i varie entre 0 et 7. L'implémentation sous-jacente peut prendre en charge plus de 8 plans de découpage, mais cela n'est pas garanti.

[deprecated] class Qt3DRender::QColorMask

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Par défaut, la propriété de chaque composante de couleur (rouge, vert, bleu, alpha) est définie sur « true », ce qui signifie qu’elles seront écrites dans le tampon d’image. Définir l’une des composantes de couleur sur « false » empêchera son écriture dans le tampon d’image.

[deprecated] class Qt3DRender::QComputeCommand

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une commande de calcul ( Qt3DRender::QComputeCommand ) sert à lancer des tâches pour le shader de calcul. Le shader de calcul est spécifié dans le composant « QMaterial » de l’entité à laquelle la commande QComputeCommand est ajoutée. Les propriétés « workGroupX », « workGroupY » et « workGroupZ » spécifient la taille des groupes de travail pour l’invocation du shader de calcul. Le nœud « Qt3DRender::QDispatchCompute » doit être présent dans le FrameGraph pour que les commandes soient effectivement exécutées.

[deprecated] class Qt3DRender::QCullFace

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

QCullFace permet de déterminer si les facettes avant ou arrière sont éliminées. Les facettes comprennent les triangles, les quadrilatères, les polygones et les rectangles.

Elle peut être ajoutée en appelant la méthode addRenderState() sur un QRenderPass:

// using namespace Qt3DRender;

QRenderPass *renderPass = new QRenderPass();

// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);

// Add the render state to the render pass
renderPass->addRenderState(cullFront);

Ou en appelant la méthode addRenderState() sur un QRenderStateSet:

// using namespace Qt3DRender;

QRenderStateSet *renderStateSet = new QRenderStateSet();

// Create a front face culling render state
QCullFace *cullFront = new QCullFace();
cullFront->setMode(QCullFace::Front);

// Add the render state to the render pass
renderStateSet->addRenderState(cullFront);

Voir également QFrontFace.

[deprecated] class Qt3DRender::QDebugOverlay

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Placer un QDebugOverlay dans une branche d'un framegraph personnalisé entraînera l'affichage d'une superposition contenant les détails de la scène, en même temps que la scène elle-même.

Le QForwardRenderer standard inclut un nœud QDebugOverlay qui peut être activé via la propriété QForwardRenderer::showDebugOverlay.

[deprecated] class Qt3DRender::QDepthRange

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Par défaut, OpenGL écrit les informations de profondeur de la scène dans le tampon de profondeur dans l'intervalle [0,0 ; 1,0], où 0,0 correspond au plan de découpe proche et 1,0 au plan de découpe lointain. QDepthRange permet de remapper ces valeurs dans une plage différente afin que certaines parties de la scène soient toujours rendues devant ou derrière d'autres parties. Les valeurs valides pour les plans de découpe proche et lointain sont comprises entre 0 et 1.

[deprecated] class Qt3DRender::QDepthTest

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe QDepthTest permet d'activer le test de profondeur à l'aide d'une fonction de test de profondeur donnée. Le test de profondeur permet d'écrire les valeurs de couleur des fragments lorsque le test est réussi, et de rejeter les fragments qui échouent au test. Le test de profondeur utilise la fonction de profondeur pour comparer la valeur de profondeur des fragments à celle du tampon z. Si la surface sous-jacente ne dispose pas de tampon z, alors QDepthTest ne fait rien.

Voir également QAlphaTest et QStencilTest.

[deprecated] class Qt3DRender::QDirectionalLight

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Une lumière directionnelle est une source lumineuse qui se comporte de manière similaire à la lumière du soleil. La lumière émise par une lumière directionnelle éclaire tous les objets depuis la même direction et avec la même intensité, quel que soit leur emplacement dans la scène.

[deprecated] class Qt3DRender::QDispatchCompute

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un « Qt3DRender::QDispatchCompute » permet de transmettre des tâches au shader de calcul afin qu’il les exécute sur le GPU. Les propriétés workGroupX, workGroupY et workGroupZ spécifient la taille des groupes de travail pour l’invocation du shader de calcul. Des composants QComputeCommand doivent être ajoutés aux entités afin d’indiquer à Qt3D de sélectionner les matériaux et la géométrie de ces entités pour l’invocation du shader de calcul. La taille des groupes de travail pour l'appel du shader correspondra à la plus grande des tailles de groupe de travail spécifiées dans `QDispatchCompute` et ` QComputeCommand`.

[deprecated] class Qt3DRender::QDithering

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe de type « Qt3DRender::QDithering » active le dithering. Le dithering ajoute du bruit aux valeurs de couleur afin de randomiser les erreurs de quantification et d'éviter ainsi l'apparition de motifs à grande échelle dans l'image finale, tels que les bandes. Le dithering est particulièrement utile lors du rendu sur une surface présentant une faible profondeur de couleur, comme RGB565 ou RGBA4444.

[deprecated] class Qt3DRender::QEffect

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

La classe QEffect regroupe un ensemble de techniques et les paramètres utilisés par ces dernières pour produire un effet de rendu pour un matériau.

Une instance de QEffect doit, dans la mesure du possible, être partagée entre plusieurs instances de « QMaterial ».

QEffect *effect = new QEffect();

// Create technique, render pass and shader
QTechnique *gl3Technique = new QTechnique();
QRenderPass *gl3Pass = new QRenderPass();
QShaderProgram *glShader = new QShaderProgram();

// Set the shader on the render pass
gl3Pass->setShaderProgram(glShader);

// Add the pass to the technique
gl3Technique->addRenderPass(gl3Pass);

// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);

// Add the technique to the effect
effect->addTechnique(gl3Technique);

Un objet ` QParameter ` défini sur un `QEffect` remplace les paramètres (du même nom) définis dans ` QTechnique ` et ` QRenderPass`, mais est lui-même remplacé par les paramètres définis dans ` QRenderPassFilter`, ` QTechniqueFilter ` et ` QMaterial`.

Voir également QMaterial, QTechnique et QParameter.

[deprecated] class Qt3DRender::QEnvironmentLight

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

QEnvironmentLight utilise des cubemaps pour mettre en œuvre l'éclairage basé sur l'image (IBL), une technique souvent utilisée en conjonction avec le rendu basé sur la physique (PBR). Les cubemaps doivent généralement être basés sur des images à plage dynamique élevée (HDR), dans un format OpenGL adapté (tel que RGBA16F) capable de gérer cette plage de valeurs étendue.

Il existe divers outils permettant de générer les cubemaps requis par QEnvironmentLight. En voici quelques exemples :

• cmftStudio
• IBLBaker
• Lys

HDRI Haven propose de nombreuses images HDR sous licence CC0 pouvant servir de matière première pour les outils cités ci-dessus.

[deprecated] class Qt3DRender::QFilterKey

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Les clés de filtre sont utilisées par QTechnique et QRenderPass pour spécifier à quelle étape du rendu la technique ou la passe de rendu est utilisée.

[deprecated] class Qt3DRender::QFrameGraphNode

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Cette classe est rarement instanciée directement car elle ne fournit aucun comportement spécifique aux graphes d’images, bien qu’elle puisse s’avérer pratique pour regrouper d’autres nœuds dans des graphes d’images dynamiques. Le comportement réel provient des sous-classes.

Les sous-classes sont les suivantes :

[deprecated] class Qt3DRender::QFrontFace

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe ` Qt3DRender::QFrontFace ` définit le sens d'enroulement des polygones orientés vers l'avant.

Voir également QCullFace.

[deprecated] class Qt3DRender::QFrustumCulling

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe QFrustumCulling permet d'effectuer un culling par frustum des entités dessinables en fonction de la vue de la caméra et des limites QGeometry des entités. Si QFrustumCulling est présente dans le FrameGraph, seules les entités dont les limites QGeometry coupent le frustum de la caméra, c'est-à-dire le champ de vision de la caméra, sont dessinées. Si QFrustumCulling n’est pas présent, toutes les entités dessinables seront dessinées. La caméra est sélectionnée par un nœud « QCameraSelector » du FrameGraph dans la hiérarchie actuelle. Le culling par frustum peut permettre de gagner beaucoup de temps de traitement GPU lorsque la scène rendue est complexe.

Voir également QCameraSelector.

[deprecated] class Qt3DRender::QGeometryRenderer

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Un objet ` Qt3DRender::QGeometryRenderer ` contient toutes les informations nécessaires au dessin d'un ` Qt3DCore::QGeometry`. Un objet `QGeometry` contient les coordonnées des données géométriques ; `QGeometryRenderer` spécifie comment interpréter ces données.

[deprecated] class Qt3DRender::QGraphicsApiFilter

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QLayer

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Qt3DRender::QLayer Elle fonctionne en conjonction avec la classe « Qt3DRender::QLayerFilter » dans le FrameGraph.

Un QLayer peut être appliqué à une sous-arborescence d'entités en définissant la propriété « recursive » sur « true ».

 #include <Qt3DCore/QEntity>
 #include <Qt3DRender/QGeometryRenderer>
 #include <Qt3DRender/QLayer>
 #include <Qt3DRender/QLayerFilter>
 #include <Qt3DRender/QViewport>

// Scene
Qt3DCore::QEntity *rootEntity = new Qt3DCore::Qt3DCore::QEntity;

Qt3DCore::QEntity *renderableEntity = new Qt3DCore::Qt3DCore::QEntity(rootEntity);
Qt3DRender::QGeometryRenderer *geometryRenderer = new Qt3DCore::QGeometryRenderer(renderableEntity);
Qt3DRender::QLayer *layer1 = new Qt3DCore::QLayer(renderableEntity);
layer1->setRecursive(true);
renderableEntity->addComponent(geometryRenderer);
renderableEntity->addComponent(layer1);

...

// FrameGraph
Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport;
Qt3DRender::QLayerFilter *layerFilter = new Qt3DRender::QLayerFilter(viewport);
layerFilter->addLayer(layer1);

...

Voir également Qt3DRender::QLayerFilter.

[deprecated] class Qt3DRender::QLayerFilter

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un filtre de couche ( Qt3DRender::QLayerFilter ) peut être utilisé pour indiquer au moteur de rendu quelle(s) couche(s) dessiner dans cette branche du graphe d'images. QLayerFilter sélectionne les entités à dessiner en fonction des instances d'QLayer ajoutées à QLayerFilter et en tant que composants à Qt3DCore::QEntity.

QLayerFilter peut être configuré pour sélectionner ou écarter des entités présentant une « QLayer » spécifique, en fonction de la propriété filterMode. Par défaut, les entités faisant référence à l’un des objets QLayer également référencés par le QLayerFilter sont sélectionnées (AcceptAnyMatchingLayers).

Au sein de l’arborescence FrameGraph, plusieurs nœuds « QLayerFilter » peuvent être imbriqués dans une branche allant de la racine à une feuille. Dans ce cas, le filtrage s’applique d’abord à toutes les entités de la scène à l’aide de la méthode de filtrage spécifiée par le premier « QLayerFilter » déclaré. Ensuite, le sous-ensemble d’entités ainsi filtré est à nouveau filtré selon la méthode de filtrage définie sur le deuxième « QLayerFilter » déclaré. Ce processus est répété jusqu’à ce que tous les nœuds « QLayerFilter » de la branche aient été traités.

[deprecated] class Qt3DRender::QLevelOfDetail

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

QLevelOfDetail permet de contrôler la représentation d'une entité en fonction de sa distance par rapport à l'observateur ou de sa taille à l'écran.

Afin d'améliorer les performances de rendu, les objets très petits peuvent être rendus avec beaucoup moins de détails, tant au niveau de la géométrie que de la texture.

Le composant est contrôlé en spécifiant des seuils de valeurs qui sont interprétés soit comme des distances par rapport à la caméra, soit comme la taille de l'écran.

À mesure que le point de vue change, la propriété ` currentIndex ` s'adapte pour refléter la valeur correspondante dans le tableau de plages.

La propriété ` currentIndex ` peut alors être utilisée, par exemple, pour activer ou désactiver des entités, changer de matériau, etc.

Le composant « LevelOfDetail » n’est pas partageable entre plusieurs instances d’ entities.

 #include <Qt3DCore/QEntity>
 #include <Qt3DRender/QGeometryRenderer>
 #include <Qt3DRender/QLevelOfDetail>

// Scene
Qt3DCore::QEntity *rootEntity = new Qt3DCore::Qt3DCore::QEntity;

Qt3DCore::QEntity *renderableEntity = new Qt3DCore::QEntity(rootEntity);
Qt3DRender::QGeometryRenderer *geometryRenderer = new Qt3DCore::QGeometryRenderer(renderableEntity);
renderableEntity->addComponent(geometryRenderer);
Qt3DRender::QLevelOfDetail* lod = new Qt3Render::QLevelOfDetail(renderableEntity);
QList<qreal> thresholds = {20, 35, 50, 65};
lod->setThresholds(thresholds);
lod->setCamera(mainCamera);
renderableEntity->addComponent(lod);

// connect to QLevelOfDetail::currentIndexChanged to toggle rendering
...

[deprecated] class Qt3DRender::QLevelOfDetailBoundingSphere

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QLevelOfDetailSwitch

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Ce composant est associé à une entité. Lorsque la distance entre l'entité et la caméra change, le QLevelOfDetailSwitch désactive toutes les entités enfants, à l'exception de celle correspondant à l'index Qt3DRender::QLevelOfDetailSwitch::currentIndex.

[deprecated] class Qt3DRender::QLineWidth

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QMaterial

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

QMaterial permet de spécifier le rendu d'un entity. N'importe quel aspect peut définir sa propre sous-classe de QMaterial afin qu'un Material puisse être utilisé pour décrire un élément visuel ; par exemple, la façon dont le son doit se répercuter sur un élément, la température d'une surface, etc.

En soi, un QMaterial ne fait rien. Ce n’est que lorsqu’il fait référence à un nœud d’ QEffect qu’un QMaterial devient utile.

En pratique, il arrive souvent qu’un même « QEffect » soit référencé par plusieurs composants QMaterial. Cela permet de ne créer les effets, les techniques, les passes et les shaders qu’une seule fois, tout en permettant de spécifier le matériau en ajoutant des instances d’ QParameter.

Un QParameter défini sur un QMaterial remplace le paramètre (du même nom) défini dans un QEffect, QTechnique et QRenderPass, mais est lui-même remplacé par le paramètre défini dans QRenderPassFilter et QTechniqueFilter.

QMaterial *material1 = new QMaterial();
QMaterial *material2 = new QMaterial();

// Create effect, technique, render pass and shader
QEffect *effect = new QEffect();
QTechnique *gl3Technique = new QTechnique();
QRenderPass *gl3Pass = new QRenderPass();
QShaderProgram *glShader = new QShaderProgram();

// Set the shader on the render pass
gl3Pass->setShaderProgram(glShader);

// Add the pass to the technique
gl3Technique->addRenderPass(gl3Pass);

// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);

// Add the technique to the effect
effect->addTechnique(gl3Technique);

// Set the effect on the materials
material1->setEffect(effect);
material2->setEffect(effect);

// Set different parameters on the materials
const QString parameterName = QStringLiteral("color");
material1->addParameter(new QParameter(parameterName, QColor::fromRgbF(0.0f, 1.0f, 0.0f, 1.0f)));
material2->addParameter(new QParameter(parameterName, QColor::fromRgbF(1.0f, 1.0f, 1.0f, 1.0f)));

Voir également QEffect, QTechnique et QParameter.

[deprecated] class Qt3DRender::QMemoryBarrier

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un nœud FrameGraph de type « Qt3DRender::QMemoryBarrier » permet de placer une barrière mémoire spécifique à un moment précis du rendu. Cela est nécessaire pour synchroniser correctement les commandes de dessin et de calcul sur le GPU.

La barrière définit l'ordre des opérations mémoire émises par une commande précédente. Cela signifie que si la commande 1 manipule un tampon destiné à être utilisé comme tampon d'attributs de sommets dans une commande 2 suivante, la barrière mémoire doit être placée après la commande 1 et le type de barrière approprié doit être défini pour le tampon d'attributs de sommets.

Lorsqu’un nœud QMemoryBarrier est détecté dans une branche du FrameGraph, la barrière sera appliquée avant toute commande de dessin ou de calcul, même si celles-ci sont définies plus loin dans la branche.

Pour le rendu OpenGL, cette page fournit plus d'informations sur le modèle de mémoire.

[deprecated] class Qt3DRender::QMesh

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Charge des données de maillage à partir de fichiers externes dans divers formats. La fonction ` Qt3DRender::QMesh ` charge les données dans un maillage unique.

Dans Qt3D 5.9, QMesh prend en charge les formats suivants :

• Wavefront OBJ
• Format triangulaire de Stanford (PLY)
• STL (STereoLithography)

QMesh prendra également en charge le format suivant si le SDK est installé et si le plugin de chargement de géométrie fbx est compilé et détecté :

• Autodesk FBX

Si vous souhaitez charger une scène entière composée de plusieurs objets, il est préférable d'utiliser plutôt l'Qt3DRender::QSceneLoader.

Voir également Qt3DRender::QSceneLoader.

[deprecated] class Qt3DRender::QMultiSampleAntiAliasing

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe « Qt3DRender::QMultiSampleAntiAliasing » permet l'anticrénelage multi-échantillonnage.

Elle peut être ajoutée à une classe ` QRenderPass ` en appelant la fonction ` QRenderPass::addRenderState()` :

QRenderPass *renderPass = new QRenderPass();

QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderPass->addRenderState(msaa);

Ou à une cible de rendu ( QRenderStateSet ) en appelant la fonction ` QRenderStateSet::addRenderState()` :

QRenderStateSet *renderStateSet = new QRenderStateSet();

QMultiSampleAntiAliasing *msaa = new QMultiSampleAntiAliasing();
renderStateSet->addRenderState(msaa);

Pour que le multisampling prenne effet, la cible de rendu doit avoir été allouée avec le multisampling activé :

QTexture2DMultisample *colorTex = new QTexture2DMultisample;
colorTex->setFormat(QAbstractTexture::RGBA8_UNorm);
colorTex->setWidth(1024);
colorTex->setHeight(1024);

QRenderTargetOutput *color = new QRenderTargetOutput;
color->setAttachmentPoint(QRenderTargetOutput::Color0);
color->setTexture(colorTex);

QTexture2DMultisample *depthStencilTex = new QTexture2DMultisample;
depthStencilTex->setFormat(QAbstractTexture::RGBA8_UNorm);
depthStencilTex->setWidth(1024);
depthStencilTex->setHeight(1024);

QRenderTargetOutput *depthStencil = new QRenderTargetOutput;
depthStencil->setAttachmentPoint(QRenderTargetOutput::DepthStencil);
depthStencil->setTexture(depthStencilTex);

Qt3DRender::QRenderTarget *renderTarget = new Qt3DRender::QRenderTarget;
renderTarget->addOutput(color);
renderTarget->addOutput(depthStencil);

De plus, le code du shader doit utiliser des types d’échantillonneurs de multisampling et la fonction `texelFetch()` à la place de `texture()`.

Par exemple, si vous avez un code tel que

#version 150

uniform sampler2D colorTexture;
in vec2 texCoord;
out vec4 fragColor;

void main()
{
    fragColor = texture(colorTexture, texCoord);
}

vous pouvez le réécrire ainsi

#version 150

uniform sampler2DMS colorTexture;
in vec2 texCoord;
out vec4 fragColor;

void main()
{
    ivec2 tc = ivec2(floor(textureSize(colorTexture) * texCoord));
    vec4 c = texelFetch(colorTexture, tc, 0) +
                texelFetch(colorTexture, tc, 1) +
                texelFetch(colorTexture, tc, 2) +
                texelFetch(colorTexture, tc, 3);
    fragColor = c / 4.0;
}

[deprecated] class Qt3DRender::QNoDepthMask

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe de type « Qt3DRender::QNoDepthMask » désactive l'écriture de la profondeur des fragments dans le tampon de profondeur.

Voir également Qt3DRender::QDepthTest.

[deprecated] class Qt3DRender::QNoDraw

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Qt3DRender::QNoDraw Elle doit être utilisée lorsque le FrameGraph doit configurer certains états de rendu ou vider certains tampons sans qu'il soit nécessaire de dessiner un maillage. Elle produit le même effet qu'un ` Qt3DRender::QRenderPassFilter ` ne correspondant à aucune des instances ` Qt3DRender::QRenderPass ` disponibles de la scène, sans le surcoût lié à l'exécution effective du filtrage.

Lorsqu’il est désactivé, un nœud « Qt3DRender::QNoDraw » n’empêche pas le rendu de la scène. L’activation ou la désactivation de la propriété « enabled » permet donc de rendre un « Qt3DRender::QNoDraw » actif ou inactif.

Qt3DRender::QNoDraw Il est généralement utilisé en tant qu’enfant d’un nœud Qt3DRender::QClearBuffers pour empêcher le rendu de la scène lorsqu’il y a plusieurs passes de rendu.

Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
Qt3DRender::QCameraSelector *cameraSelector = new Qt3DRender::QCameraSelector(viewport);

Qt3DRender::QClearBuffers *clearBuffers = new Qt3DRender::QClearBuffers(cameraSelector);
clearBuffers->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);

Qt3DRender::QNoDraw *noDraw = new Qt3DRender::QNoDraw(clearBuffers);

Qt3DRender::QRenderPassFilter *mainPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....
Qt3DRender::QRenderPassFilter *previewPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....

[deprecated] class Qt3DRender::QNoPicking

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Lorsqu’elle est désactivée, une nœud « Qt3DRender::QNoPicking » n’empêche pas la sélection d’être effectuée. L’activation ou la désactivation de la propriété « enabled » permet donc de rendre une « Qt3DRender::QNoPicking » active ou inactive.

Lors de l’utilisation de plusieurs sous-fenêtres dans le FrameGraph, QNoPicking peut s’avérer utile pour éviter les conflits de sélection entre des fenêtres qui se chevauchent ou qui ne sont pas visibles. Il peut également servir d’optimisation afin d’éviter tout travail inutile sur les fenêtres masquées ou sur les parties de la scène ne nécessitant aucune sélection.

Qt3DRender::QViewport *viewport = new Qt3DRender::QViewport();
Qt3DRender::QCameraSelector *cameraSelector = new Qt3DRender::QCameraSelector(viewport);
Qt3DRender::QNoPicking *noPicking = new Qt3DRender::QNoPicking(cameraSelector);

Qt3DRender::QClearBuffers *clearBuffers = new Qt3DRender::QClearBuffers(noPicking);
clearBuffers->setBuffers(Qt3DRender::QClearBuffers::ColorDepthBuffer);

Qt3DRender::QRenderPassFilter *mainPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....
Qt3DRender::QRenderPassFilter *previewPass = new Qt3DRender::QRenderPassFilter(cameraSelector);
....

Voir également Qt3DRender::QObjectPicker, Qt3DRender::QRayCaster et Qt3DRender::QScreenRayCaster.

[deprecated] class Qt3DRender::QObjectPicker

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Pour chaque combinaison de fenêtre d'affichage et de caméra, la fonction « picking » projette un rayon à travers la scène afin de trouver les entités dont le volume englobant coupe ce rayon. Le volume englobant est calculé à partir des valeurs contenues dans le tampon d'attributs spécifié par l'attribut `boundingVolumePositionAttribute` de la géométrie.

Les signaux pressed(), released(), clicked(), moved(), entered() et exited() sont émis lorsque le volume englobant défini par la propriété `pickAttribute` croise un rayon.

La plupart des signaux transportent une instance de ` QPickEvent `. Si `QPickingSettings::pickMode()` est défini sur ` QPickingSettings::TrianglePicking`, le type réel du paramètre de sélection sera ` QPickTriangleEvent`.

Les requêtes de sélection sont effectuées lors de l’activation et de la désactivation du bouton de la souris. Si le glissement est activé, des requêtes ont également lieu à chaque déplacement de la souris tant qu’un bouton est enfoncé. Si le survol est activé, des requêtes ont lieu à chaque déplacement de la souris, même si aucun bouton n’est enfoncé.

Pour les requêtes de ray casting généralisées, voir Qt3DRender::QRayCaster et Qt3DRender::QScreenRayCaster.

Voir également Qt3DRender::QPickingSettings, Qt3DCore::QGeometry, Qt3DCore::QAttribute, Qt3DRender::QPickEvent, Qt3DRender::QPickTriangleEvent et Qt3DRender::QNoPicking.

[deprecated] class Qt3DRender::QPaintedTextureImage

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe `QPaintedTextureImage` permet de spécifier une image de texture (et donc une texture OpenGL) via une fonction ` QPainter`. La largeur et la hauteur de l'image de texture peuvent être spécifiées via les propriétés `width`, `height` ou `size`.

Un objet `QPaintedTextureImage` doit être sous-classé et la fonction virtuelle ` paint()` doit être implémentée. Chaque fois que la fonction ` update()` est appelée sur l'objet `QPaintedTextureImage`, la fonction ` paint()` est invoquée et l'image résultante est chargée.

Le QPaintedTextureImage doit être associé à un QAbstractTexture.

[deprecated] class Qt3DRender::QParameter

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un QParameter peut être référencé par un QRenderPass, QTechnique, QEffect, QMaterial, QTechniqueFilter ou QRenderPassFilter. Lors de l'exécution, selon le shader sélectionné pour une étape donnée du rendu, la valeur contenue dans un QParameter sera convertie et chargée si le shader contient un uniforme dont le nom correspond à celui du QParameter.

QParameter *param = new QParameter();
param->setName(QStringLiteral("diffuseColor"));
param->setValue(QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));

// Alternatively you can create and set a QParameter this way
QParameter *param2 = new QParameter(QStringLiteral("diffuseColor"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));

// Such QParameters will work with the following GLSL uniform shader declarations
// uniform vec4 diffuseColor;
// uniform vec3 diffuseColor;
// uniform vec2 diffuseColor;
// uniform float diffuseColor;

QParameter *param = new QParameter();
QVariantList values = QVariantList() << 0.0f << 1.0f << 2.0f << 3.0f << 4.0f << 883.0f << 1340.0f << 1584.0f;

param->setName(QStringLiteral("diffuseValues[0]"));
param->setValue(values);

// Matching GLSL shader uniform  declaration
// uniform float diffuseValues[8];

En ce qui concerne la prise en charge des textures, la valeur de QParameter doit être définie sur la sous-classe appropriée de ` QAbstractTexture ` qui correspond au type d’échantillonneur de l’uniforme du shader.

QTexture2D *texture = new QTexture2D();
...
QParameter *param = new QParameter();
param->setName(QStringLiteral("diffuseTexture"));
param->setValue(QVariant::fromValue(texture));

// Works with the following GLSL uniform shader declaration
// uniform sampler2D diffuseTexture

Voir également QAbstractTexture.

[deprecated] class Qt3DRender::QPickEvent

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Elle est reçue en tant que paramètre dans la plupart des signaux du composant QObjectPicker lorsque la sélection aboutit.

Voir également QPickingSettings, QPickTriangleEvent et QObjectPicker.

[deprecated] class Qt3DRender::QPickLineEvent

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Voir également QPickEvent.

[deprecated] class Qt3DRender::QPickPointEvent

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Voir également QPickEvent.

[deprecated] class Qt3DRender::QPickTriangleEvent

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Lorsque QPickingSettings::pickMode() est défini sur « QPickingSettings::TrianglePicking », les signaux de QObjectPicker transmettront une instance de QPickTriangleEvent.

Celui-ci contient les détails du triangle qui a été sélectionné.

Voir également QPickingSettings, QPickEvent et QObjectPicker.

[since 6.0, deprecated] class Qt3DRender::QPickingProxy

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Le picking peut être une opération coûteuse, en particulier si le maillage comporte un grand nombre de sommets. QPickProxy peut être utilisé pour fournir une géométrie alternative, généralement comportant moins de primitives, qui sera utilisée pour le picking, tandis que l'instance GeometryRenderer sera utilisée pour le rendu.

Cette classe a été introduite dans Qt 6.0.

[deprecated] class Qt3DRender::QPickingSettings

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Les paramètres de sélection déterminent la manière dont la sélection des entités est gérée. Pour plus de détails sur la sélection des entités, consultez la documentation relative aux composants QObjectPicker et QRayCaster.

Lors de l'utilisation des composants QObjectPicker, la sélection est déclenchée par des événements de souris.

Lorsque vous utilisez les composants QRayCaster ou QScreenRayCaster, la sélection peut être déclenchée explicitement par l'application.

Dans les deux cas, un rayon est projeté à travers la scène afin de trouver les éléments géométriques qui le coupent.

Voir également QObjectPicker, QPickEvent, QPickTriangleEvent, QRayCaster et QScreenRayCaster.

[deprecated] class Qt3DRender::QPointLight

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une lumière ponctuelle est une source lumineuse qui émet de la lumière dans toutes les directions à partir d'un seul point. D'un point de vue conceptuel, cela s'apparente à la lumière émise par une ampoule classique.

Une lumière ponctuelle utilise trois facteurs d'atténuation pour décrire la façon dont l'intensité de la lumière diminue en fonction de la distance. Ces facteurs sont conçus pour être utilisés conjointement dans le calcul de l'atténuation totale. Pour les matériaux de Qt3D Extras, la formule suivante est utilisée, où « distance » correspond à la distance entre la lumière et la surface rendue :

totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));

Les matériaux personnalisés peuvent choisir d'interpréter ces facteurs différemment.

[deprecated] class Qt3DRender::QPointSize

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Lorsque la propriété « sizeMode » est définie sur « SizeMode::Fixed », la valeur est définie à l’aide de la fonction glPointSize(), si celle-ci est disponible. En cas d’utilisation de « SizeMode::Programmable », la valeur de gl_PointSize doit être définie au sein des programmes de shader ; la valeur fournie à cette « RenderState » est alors ignorée.

[deprecated] class Qt3DRender::QPolygonOffset

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe QPolygonOffset ajoute un décalage à la valeur de profondeur du fragment avant le test de profondeur et l'écriture de profondeur. Ce décalage peut être utilisé pour éviter les conflits de z lors du rendu de polygones présentant des valeurs de profondeur très proches, comme les décalcomanies.

[deprecated] class Qt3DRender::QProximityFilter

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une instance de ` Qt3DRender::QProximityFilter ` peut être utilisée pour sélectionner les entités à afficher lorsqu'elles se trouvent à une distance inférieure à un seuil donné par rapport à une autre entité.

[deprecated] class Qt3DRender::QRasterMode

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe QRasterMode sert à contrôler l'étape de rastérisation des primitives au moment du rendu. Elle permet de choisir si l'on souhaite uniquement afficher les points, les arêtes ou remplir une primitive.

Voir également QAlphaTest et QStencilTest.

[deprecated] class Qt3DRender::QRayCaster

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Le rayon 3D est défini par son origine, sa direction et sa longueur. Il sera affecté par les transformations appliquées à l'entité à laquelle il appartient.

Des tests de ray casting seront effectués à chaque image tant que le composant est activé. La propriété `hits` sera mise à jour avec la liste des intersections.

Voir également QAbstractRayCaster, QScreenRayCaster et QNoPicking.

[deprecated] class Qt3DRender::QRayCasterHit

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Qt3DRender::QRayCasterHit Contient les détails d'un impact réussi lors du lancer d'un rayon à travers un modèle à l'aide d'un composant Qt3DRender::QRayCaster ou Qt3DRender::QScreenRayCaster.

Voir également Qt3DRender::QRayCaster, Qt3DRender::QScreenRayCaster et Qt3DRender::QPickingSettings.

[deprecated] class Qt3DRender::QRenderAspect

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du code nouveau.

[deprecated] class Qt3DRender::QRenderCapabilities

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

QRenderCapabilities fournit des informations détaillées sur les fonctionnalités graphiques disponibles lors de l'exécution. Elle peut être utilisée pour déterminer le chemin d'exécution à emprunter pour certains algorithmes, par exemple en fonction de la disponibilité ou non des shaders de calcul.

[deprecated] class Qt3DRender::QRenderCapture

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

L'objet QRenderCapture sert à capturer le rendu sous forme d'image à n'importe quelle étape du rendu. La capture doit être lancée par l'utilisateur et une image est renvoyée par requête de capture. L'utilisateur peut émettre plusieurs requêtes de capture de rendu simultanément, mais une seule requête est traitée par instance QRenderCapture et par image.

[deprecated] class Qt3DRender::QRenderCaptureReply

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Objet qui reçoit l'image depuis QRenderCapture::requestCapture.

[deprecated] class Qt3DRender::QRenderPass

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un « Qt3DRender::QRenderPass » spécifie un passage de rendu unique (c'est-à-dire une exécution du programme de shader) utilisé par Qt3DRender::QTechnique. Un passage de rendu se compose d'un « Qt3DRender::QShaderProgram » et d'une liste d'objets « Qt3DRender::QFilterKey », d'une liste d'objets « Qt3DRender::QRenderState » et d'une liste d'objets « Qt3DRender::QParameter ».

QRenderPass exécute l’ QShaderProgram en utilisant les nœuds QRenderState et QParameter fournis lorsqu’au moins l’un des nœuds QFilterKey référencés correspond à l’un des nœuds QFilterKey de QRenderPassFilter, ou lorsqu’aucun nœud QFilterKey n’est spécifié et qu’aucun QRenderPassFilter n’est présent dans le FrameGraph.

Si le QRenderPass définit un QParameter, celui-ci sera remplacé par un QParameter portant le même nom s’il existe dans l’un des QTechnique, QEffect, QMaterial, QTechniqueFilter ou QRenderPassFilter associés au pass lors de l’exécution. Cela peut néanmoins s’avérer utile pour définir des valeurs par défaut raisonnables.

Au moment du rendu, pour chaque nœud feuille du FrameGraph, un état de rendu de base est enregistré en cumulant les états définis par tous les nœuds « QRenderStateSet » de la branche du FrameGraph. Chaque QRenderPass peut redéfinir cet état de rendu de base en spécifiant ses propres nœuds « QRenderState ».

// Create the render passes
QRenderPass *pass = new QRenderPass();

// Create shader program
QShaderProgram *glShader = new QShaderProgram();

// Set the shader on the render pass
pass->setShaderProgram(glShader);

// Create a FilterKey
QFilterKey *filterKey = new QFilterKey();
filterKey->setName(QStringLiteral("name"));
fitlerKey->setValue(QStringLiteral("zFillPass"));

// Add the FilterKey to the pass
pass->addFilterKey(filterKey);

// Create a QParameter
QParameter *colorParameter = new QParameter(QStringLiteral("color"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));

// Add parameter to pass
pass->addParameter(colorParameter);

// Create a QRenderState
QDepthTest *depthTest = new QDepthTest();

// Add the render state to the pass
pass->addRenderState(depthTest);

Voir également QRenderPassFilter, QFilterKey, QParameter, QRenderState, QEffect et QTechnique.

[deprecated] class Qt3DRender::QRenderPassFilter

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un nœud Qt3DRender::QRenderPassFilter du FrameGraph sert à sélectionner les objets Qt3DRender::QRenderPass à afficher. QRenderPassFilter spécifie une liste d’objets Qt3DRender::QFilterKey et d’objets Qt3DRender::QParameter. Lorsque QRenderPassFilter est présent dans le FrameGraph, seuls les objets QRenderPass dont les objets Qt3DRender::QFilterKey correspondent aux clés de QRenderPassFilter sont sélectionnés pour le rendu. Si aucun QRenderPassFilter n’est présent, tous les objets ` QRenderPass ` sont sélectionnés pour le rendu. Les paramètres de la liste peuvent être utilisés pour définir les valeurs des paramètres de shader. Les paramètres de QRenderPassFilter remplacent ceux de ` QTechniqueFilter`, ` QMaterial`, ` QEffect`, ` QTechnique ` et ` QRenderPass`.

[deprecated] class Qt3DRender::QRenderSettings

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Le composant QRenderSettings doit être défini en tant que composant de l'entité racine de la scène. Il spécifie la politique de rendu et les paramètres de sélection, et héberge le FrameGraph actif.

[deprecated] class Qt3DRender::QRenderState

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe ` Qt3DRender::QRenderState ` est une classe de base abstraite pour tous les états de rendu. Il n'est pas possible d'instancier directement `QRenderState`, mais uniquement via ses sous-classes.

[deprecated] class Qt3DRender::QRenderStateSet

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Les états définis sur un QRenderStateSet sont définis globalement, contrairement aux états propres à chaque matériau qui peuvent être définis sur un QRenderPass. Par défaut, un QRenderStateSet vide entraînera la désactivation de tous les états de rendu lors de l'exécution. L'ajout d'un état QRenderState active explicitement cet état de rendu lors de l'exécution.

L’ RenderStateSet est activé lorsqu’il est ajouté au graphe de trames actif :

// using namespace Qt3DRender;

Qt3DCore::QEntity *rootEntity = new Qt3DCore::QEntity();

QRenderSettings *renderSettings = new QRenderSettings();

QViewport *viewport = new QViewport();
QCameraSelector *cameraSelector = new QCameraSelector(viewport);

QClearBuffers *clearBuffers = new QClearBuffers(cameraSelector);
clearBuffers->setBuffers(QClearBuffers::ColorDepthBuffer);

QRenderStateSet *renderStateSet = new QRenderStateSet(cameraSelector);
QCullFace *cullFace = new QCullFace(renderStateSet);
cullFace->setMode(QCullFace::Front);
renderStateSet->addRenderState(cullFace);

renderSettings->setActiveFrameGraph(viewport);

rootEntity->addComponent(renderSettings);

Voir également QRenderState et QRenderPass.

[deprecated] class Qt3DRender::QRenderSurfaceSelector

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe « Qt3DRender::QRenderSurfaceSelector » permet de sélectionner la surface sur laquelle Qt3D affiche le contenu. Il peut s'agir soit d'une surface de fenêtre, soit d'une surface hors écran. La classe « externalRenderTargetSize » sert à spécifier la taille réelle de la surface lorsqu'une surface hors écran est utilisée.

Lorsque le système utilise la mise à l'échelle DPI, la taille logique de la surface, qui est utilisée par les événements de souris, et la taille « physique » réelle de la surface peuvent différer. Le paramètre ` surfacePixelRatio ` est le facteur permettant de convertir la taille logique en taille physique.

Voir également QWindow, QOffscreenSurface et QSurface.

[deprecated] class Qt3DRender::QRenderTarget

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un « Qt3DRender::QRenderTarget » est constitué d’objets « Qt3DRender::QRenderTargetOutput », qui spécifient les tampons vers lesquels la cible de rendu effectue le rendu. L’utilisateur peut spécifier des cibles de rendu multiples (MRT, Multiple Render Targets) en associant plusieurs textures à différents points d’attache. Le comportement est indéfini si l’utilisateur tente d’associer plusieurs textures au même point d’attache. Au moment du rendu, seuls les tampons de dessin spécifiés dans l’ Qt3DRender::QRenderTargetSelector s sont utilisés.

[deprecated] class Qt3DRender::QRenderTargetOutput

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une instance QRenderTargetOutput spécifie le point d’attache et les paramètres de la texture associée à la cible de rendu. Outre le point d’attache, il est possible de spécifier le niveau de mip, la couche et la face de la carte cubique de la texture. La texture associée à l’instance QRenderTargetOutput doit être compatible avec les paramètres fournis.

[deprecated] class Qt3DRender::QRenderTargetSelector

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un « Qt3DRender::QRenderTargetSelector » sert à sélectionner des cibles de rendu actives ( Qt3DRender::QRenderTarget ) pour le FrameGraph. Lorsque QRenderTargetSelector est présent dans le FrameGraph, le rendu est dirigé vers des objets QTexture ou des tampons de dessin (draw buffers) au lieu de la surface spécifiée dans l'Qt3DRender::QRenderSurfaceSelector.

[deprecated] class Qt3DRender::QSceneLoader

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

À partir d’un fichier source 3D, le chargeur ( Qt3DRender::QSceneLoader ) tentera de l’analyser et de construire une arborescence d’objets « Qt3DCore::QEntity » avec les composants appropriés : « Qt3DRender::QGeometryRenderer », « Qt3DCore::QTransform » et « Qt3DRender::QMaterial ».

Le chargeur tentera de déterminer le meilleur matériau à utiliser en fonction des propriétés du fichier de modèle. Si vous souhaitez utiliser un matériau personnalisé, vous devrez parcourir l’arborescence et remplacer les matériaux par défaut associés par les vôtres.

Comme son nom l’indique, la fonction « Qt3DRender::QSceneLoader » charge une sous-arborescence complète de la scène. Si vous souhaitez charger un seul élément géométrique, vous devriez plutôt utiliser la fonction « Qt3DRender::QMesh ».

Qt3DRender::QSceneLoader S'appuie en interne sur l'utilisation de plugins pour prendre en charge une grande variété de formats de fichiers 3D. Voici une liste des formats pris en charge par Qt3D.

Voir également Qt3DRender::QMesh et Qt3DRender::QGeometryRenderer.

[deprecated] class Qt3DRender::QScissorTest

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe QScissorTest active le test « scissor », qui élimine les fragments situés en dehors de la zone rectangulaire de l'écran définie par les propriétés left, bottom, width et height.

[deprecated] class Qt3DRender::QScreenRayCaster

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

QScreenRayCaster permet d'effectuer des tests de ray casting en spécifiant des coordonnées dans l'espace écran, qui seront utilisées pour construire un rayon 3D réel entre les plans proche et lointain.

Voir également QRayCaster et QNoPicking.

[deprecated] class Qt3DRender::QSeamlessCubemap

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Lorsqu'elle est présente dans un ensemble d'états, elle active le filtrage transparent des textures cubemap fourni par l'extension GL_ARB_seamless_cubemap (si disponible).

[deprecated] class Qt3DRender::QSetFence

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Les « fences » permettent de synchroniser les charges de travail du GPU et du CPU. Les commandes GPU sont généralement non bloquantes. Lorsqu'elles sont émises, les commandes sont insérées dans des tampons de commandes qui seront lus ultérieurement par le GPU. Dans certains cas, vous souhaitez poursuivre le traitement ou émettre une commande spécifique uniquement lorsque vous êtes certain qu'une commande a bien été exécutée par le matériel. Les « fences » constituent un moyen d’y parvenir. Ceci est particulièrement important lors de l’utilisation de moteurs tiers avec Qt3D : Qt3D ne doit accéder aux ressources partagées que lorsque l’on sait que les commandes de l’autre moteur ont fini de modifier la ressource.

QSetFence est un nœud FrameGraph qui insère une barrière dans le flux de commandes. Il peut ensuite être utilisé conjointement avec QWaitFence ou en extrayant le descripteur sous-jacent.

La propriété « handle » sera mise à jour une fois que le moteur de rendu aura créé la ressource de barrière sous-jacente. Le descripteur restera valide tant qu’il se trouvera à l’état « unsignaled ». Une fois qu’il aura atteint l’état « signaled », il sera détruit et un nouveau descripteur sera créé. Cela signifie que, selon le temps nécessaire pour que la barrière soit signalée, le même descripteur pourrait être utilisé sur plusieurs images.

[deprecated] class Qt3DRender::QShaderData

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QShaderImage

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Pour que le contenu des textures soit accessible aux opérations de lecture et d'écriture dans un shader, celles-ci doivent être exposées sous la forme d'un objet `QShaderImage`. Les textures peuvent être composées de plusieurs niveaux de mip, couches et faces. De plus, la déclaration d'un objet `QShaderImage` permet de spécifier le niveau, la couche ou la face du contenu de la texture auquel on souhaite accéder.

Pour fonctionner correctement, QShaderImage doit être attribué comme valeur d’un objet ` QParameter` et faire référence à un ` Qt3DRender::QAbstractTexture ` valide.

Si la texture référencée est un tableau unidimensionnel, bidimensionnel ou tridimensionnel, une carte cubique, un tableau de cartes cubiques ou une texture bidimensionnelle à échantillonnage multiple, il est possible de lier soit l’intégralité du niveau de texture, soit un seul calque ou une seule face de ce niveau. Ce comportement peut être contrôlé à l’aide de la propriété layered.

La prise en charge de QShaderImage n'est assurée qu'avec OpenGL 4 et partiellement avec OpenGL ES 3.1 et 3.2.

OpenGL 4 prend en charge les types d’images suivants :

OpenGL ES 3.1 prend en charge les types d'images suivants :

OpenGL ES 3.2 prend en charge tous les types d’images d’OpenGL ES 3.1 ainsi que les suivants :

L'utilisation prévue ressemblerait à ceci :

Qt3DRender::QTexture2D *tex2D = new Qt3DRender::QTexture2D();
...
Qt3DRender::QMaterial *material = new Qt3DRender::QMaterial();
...
Qt3DRender::QParameter *imageParameter = new Qt3DRender::QParameter();
Qt3DRender::QShaderImage *shaderImage = new Qt3DRender::QShaderImage();

shaderImage->setTexture(tex2D);

imageParameter->setName("imageUniformName");
imageParameter->setValue(QVariant::fromValue(shaderImage));

material->addParameter(imageParamenter);

[deprecated] class Qt3DRender::QShaderProgram

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Un programme de shaders se compose de plusieurs shaders différents, tels que les shaders de sommets et de fragments.

Qt3D renseignera automatiquement un ensemble d'uniformes par défaut s'il les détecte lors de la phase d'introspection du shader.

Prise en charge de RHI

Lors de l'écriture de code de shader GLSL 450 destiné à être utilisé avec le backend RHI d’ Qt 3D, les uniformes par défaut seront fournis sous la forme de 2 objets de tampon d’uniformes.

Leurs emplacements de liaison sont définis sur 0 pour les uniformes RenderView et sur 1 pour les uniformes Command.

#version 450 core

layout(location = 0) in vec3 vertexPosition;

layout(std140, binding = 0) uniform qt3d_render_view_uniforms {
  mat4 viewMatrix;
  mat4 projectionMatrix;
  mat4 uncorrectedProjectionMatrix;
  mat4 clipCorrectionMatrix;
  mat4 viewProjectionMatrix;
  mat4 inverseViewMatrix;
  mat4 inverseProjectionMatrix;
  mat4 inverseViewProjectionMatrix;
  mat4 viewportMatrix;
  mat4 inverseViewportMatrix;
  vec4 textureTransformMatrix;
  vec3 eyePosition;
  float aspectRatio;
  float gamma;
  float exposure;
  float time;
  float yUpInNDC;
  float yUpInFBO;
};

layout(std140, binding = 1) uniform qt3d_command_uniforms {
  mat4 modelMatrix;
  mat4 inverseModelMatrix;
  mat4 modelViewMatrix;
  mat3 modelNormalMatrix;
  mat4 inverseModelViewMatrix;
  mat4 modelViewProjection;
  mat4 inverseModelViewProjectionMatrix;
};

void main()
{
    gl_Position = (projectionMatrix * viewMatrix * modelMatrix * vertexPosition);
}

Pour les objets de tampon uniformes définis par l'utilisateur, utilisez un emplacement de liaison à partir de 2 ou « auto » pour laisser Qt 3D déterminer automatiquement la liaison. Veillez à maintenir la cohérence entre les différentes étapes du shader.

#version 450 core

layout(std140, binding = auto) uniform my_uniforms {
  vec4 myColor;
};

layout(location=0) out vec4 fragColor;

void main()
{
    fragColor = myColor;
}

Il n’y a aucun changement à effectuer en ce qui concerne la transmission des valeurs aux uniformes.

Pour l’exemple ci-dessus, la définition de myColor pourrait s’effectuer ainsi :

QParameter *parameter = new QParameter();
parameter->setName("myColor");
parameter->setValue(QVariant::fromValue(QColor(Qt::blue)));

Les textures doivent toujours être définies en tant qu’uniformes autonomes.

#version 450 core

layout(binding=0) uniform sampler2D source;

layout(location=0) out vec4 fragColor;

void main()
{
    fragColor = texture(source, vec2(0.5, 0.5));
}

[deprecated] class Qt3DRender::QShaderProgramBuilder

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

Un générateur de programmes de shaders se compose de plusieurs graphes de shaders différents utilisés pour générer du code de shader.

Un cache contenant le code de shader généré est géré. Par défaut, les shaders générés sont enregistrés dans QStandardPaths::writableLocation(QStandardPaths::TempLocation)). Ce chemin d'accès peut être redéfini en définissant la variable d'environnement QT3D_WRITABLE_CACHE_PATH sur un chemin d'accès valide et accessible en écriture.

L’utilisation du cache peut être désactivée en définissant la variable d’environnement QT3D_DISABLE_SHADER_CACHE.

Dans la plupart des cas, les modifications apportées à un graphe sont détectées par Qt 3D et une nouvelle entrée de cache est générée. Cela ne se produit toutefois pas lorsque des extraits de code inclus dans un graphe sont modifiés. Pour contourner ce problème, il est possible de vider le répertoire du cache ou de définir la variable d’environnement QT3D_REBUILD_SHADER_CACHE afin de forcer la régénération du code de shader.

[deprecated] class Qt3DRender::QSharedGLTexture

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Selon le mode de rendu utilisé par Qt 3D, le contexte partagé sera soit :

• qt_gl_global_share_context lorsque le rendu est géré par Qt 3D. Lorsque l'attribut Qt::AA_ShareOpenGLContexts est défini sur la classe QApplication, cela fait automatiquement en sorte que les instances de QOpenGLWidget partagent leur contexte avec qt_gl_global_share_context.
• le contexte partagé de la scène QtQuick. Vous devrez peut-être créer une sous-classe de QWindow ou utiliser QtQuickRenderControl pour contrôler la nature de ce contexte partagé ; toutefois, à partir de la version 5.13, il s’agit de qt_gl_global_share_context.

Tout moteur tiers partageant son contexte avec le moteur de rendu « Qt 3D » peut désormais fournir des identifiants de texture qui seront référencés par la texture « Qt 3D ».

Vous pouvez omettre de spécifier les propriétés de la texture ; Qt 3D tentera de les déterminer lors de l’exécution. Si vous les connaissez, vous pouvez bien sûr les fournir, ce qui évitera un travail supplémentaire à Qt 3D.

Gardez à l’esprit que si vous utilisez des matériaux et des shaders personnalisés, vous devez spécifier le type d’échantillonneur approprié à utiliser.

[deprecated] class Qt3DRender::QSortPolicy

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe ` Qt3DRender::QSortPolicy ` stocke le type de tri utilisé par le `FrameGraph`. Les types de tri déterminent la manière dont les entités dessinables sont triées avant le dessin afin de définir l'ordre de dessin. Lorsque `QSortPolicy` est présente dans le `FrameGraph`, le mécanisme de tri est déterminé par la liste ` sortTypes `. Plusieurs types de tri peuvent être utilisés simultanément. Si QSortPolicy n’est pas présent dans le FrameGraph, les entités sont dessinées dans l’ordre où elles apparaissent dans la hiérarchie des entités.

[deprecated] class Qt3DRender::QSpotLight

Cette classe est obsolète. Nous déconseillons vivement de l'utiliser dans du nouveau code.

Un projecteur est une source lumineuse qui émet un cône de lumière dans une direction particulière.

Un projecteur utilise trois facteurs d'atténuation pour décrire la façon dont l'intensité de la lumière diminue en fonction de la distance. Ces facteurs sont conçus pour être utilisés conjointement dans le calcul de l'atténuation totale. Pour les matériaux de Qt3D Extras, la formule suivante est utilisée, où « distance » correspond à la distance entre la source lumineuse et la surface à rendre :

totalAttenuation = 1.0 / (constantAttenuation + (linearAttenuation * distance) + (quadraticAttenuation * distance * distance));

Les matériaux personnalisés peuvent choisir d'interpréter ces facteurs différemment.

[deprecated] class Qt3DRender::QStencilMask

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe ` Qt3DRender::QStencilMask ` spécifie un masque d'écriture pour les valeurs de stencil après le test de stencil. Le masque peut être spécifié séparément pour les polygones orientés vers l'avant et ceux orientés vers l'arrière. La valeur de stencil du fragment est combinée par un « ET » avec le masque avant d'être écrite dans le tampon de stencil.

Voir également Qt3DRender::QStencilTest.

[deprecated] class Qt3DRender::QStencilOperation

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe « Qt3DRender::QStencilOperation » spécifie les opérations de stencil pour les polygones orientés vers l'avant et vers l'arrière. Les opérations de stencil déterminent ce qui est effectué sur les fragments lorsque les tests de stencil et de profondeur sont réussis ou échoués.

Voir également Qt3DRender::QStencilTest.

[deprecated] class Qt3DRender::QStencilOperationArguments

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe ` Qt3DRender::QStencilOperationArguments ` spécifie les arguments des opérations de stencil.

Voir aussi Qt3DRender::QStencilOperation.

[deprecated] class Qt3DRender::QStencilTest

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Une classe ` Qt3DRender::QStencilTest ` spécifie les arguments du test de stencil. Le test de stencil comprend trois arguments : la fonction de test de stencil, le masque de test de stencil et la valeur de référence du stencil. `QStencilTest` permet de définir ces arguments séparément pour les polygones orientés vers l'avant et vers l'arrière.

Voir également Qt3DRender::QStencilMask et Qt3DRender::QStencilOperation.

[deprecated] class Qt3DRender::QStencilTestArguments

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

La classe ` Qt3DRender::QStencilTestArguments ` spécifie les arguments du test de stencil.

[deprecated] class Qt3DRender::QSubtreeEnabler

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Bien que les nœuds QFrameGraphNodes puissent être activés et désactivés individuellement via la propriété enabled, cela peut s'avérer fastidieux lorsqu'il faut activer ou désactiver un chemin entier. QSubtreeEnabler est un nœud pratique qui simplifie considérablement ce cas d'utilisation, en permettant de contrôler tous ses enfants à l'aide d'un seul commutateur.

QSubtreeEnabler est activé par défaut.

[deprecated] class Qt3DRender::QTechnique

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un objet ` Qt3DRender::QTechnique ` spécifie un ensemble d'objets ` Qt3DRender::QRenderPass `, ` Qt3DRender::QFilterKey `, ` Qt3DRender::QParameter ` et un ` Qt3DRender::QGraphicsApiFilter`, qui définissent ensemble une technique de rendu que l'API graphique donnée est capable de prendre en charge. Les clés de filtre sont utilisées par Qt3DRender::QTechniqueFilter pour sélectionner des techniques spécifiques à des parties spécifiques du FrameGraph. Un QParameter défini sur un nœud QTechnique remplace le paramètre (du même nom) défini dans QRenderPass, mais est lui-même remplacé par les paramètres définis dans QRenderPassFilter, QTechniqueFilter, QMaterial et QEffect.

Lors de la création d’une technique de rendu ( QEffect ) ciblant plusieurs versions d’une API graphique, il est utile de créer plusieurs nœuds QTechnique, chacun avec une technique de rendu ( graphicsApiFilter ) définie pour correspondre à l’une des versions GL ciblées. Au moment de l’exécution, le moteur de rendu Qt3D sélectionnera la QTechnique la plus appropriée en fonction des versions de l’API graphique prises en charge et (si spécifié) des nœuds « QFilterKey » qui satisfont à une « QTechniqueFilter » donnée dans le FrameGraph.

QTechnique *gl3Technique = new QTechnique();

// Create the render passes
QRenderPass *firstPass = new QRenderPass();
QRenderPass *secondPass = new QRenderPass();

// Add the passes to the technique
gl3Technique->addRenderPass(firstPass);
gl3Technique->addRenderPass(secondPass);

// Set the targeted GL version for the technique
gl3Technique->graphicsApiFilter()->setApi(QGraphicsApiFilter::OpenGL);
gl3Technique->graphicsApiFilter()->setMajorVersion(3);
gl3Technique->graphicsApiFilter()->setMinorVersion(1);
gl3Technique->graphicsApiFilter()->setProfile(QGraphicsApiFilter::CoreProfile);

// Create a FilterKey
QFilterKey *filterKey = new QFilterKey();
filterKey->setName(QStringLiteral("name"));
fitlerKey->setValue(QStringLiteral("zFillPass"));

// Add the FilterKey to the Technique
gl3Technique->addFilterKey(filterKey);

// Create a QParameter
QParameter *colorParameter = new QParameter(QStringLiteral("color"), QColor::fromRgbF(0.0f, 0.0f, 1.0f, 1.0f));

// Add parameter to technique
gl3Technique->addParameter(colorParameter);

Voir également QEffect, QRenderPass et QTechniqueFilter.

[deprecated] class Qt3DRender::QTechniqueFilter

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Un ` Qt3DRender::QTechniqueFilter ` spécifie les techniques utilisées par le `FrameGraph` lors du rendu des entités. `QTechniqueFilter` spécifie une liste d'objets ` Qt3DRender::QFilterKey ` et d'objets ` Qt3DRender::QParameter `. Lorsque `QTechniqueFilter` est présent dans le `FrameGraph`, seules les techniques correspondant aux clés de la liste sont utilisées pour le rendu. Les paramètres de la liste peuvent servir à définir des valeurs pour les paramètres de shader. Les paramètres de QTechniqueFilter remplacent ceux de QMaterial, QEffect, QTechnique et QRenderPass, mais sont eux-mêmes remplacés par les paramètres de QRenderPassFilter.

[deprecated] class Qt3DRender::QTexture1D

Cette classe est obsolète. Nous vous déconseillons vivement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture1DArray

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture2D

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture2DArray

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture2DMultisample

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture2DMultisampleArray

Cette classe est obsolète. Nous vous déconseillons vivement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTexture3D

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureBuffer

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureCubeMap

Cette classe est obsolète. Nous vous déconseillons vivement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureCubeMapArray

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureData

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureDataUpdate

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Le contenu réel des données est stocké dans un membre de type « QTextureImageDataPtr ». Des membres supplémentaires permettent de spécifier les décalages x, y, z de la mise à jour du contenu, ainsi que la couche, le niveau de mip et la face éventuels.

Voir également QAbstractTexture.

[deprecated] class Qt3DRender::QTextureImage

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Elle contient les informations nécessaires (niveau de mipmap, couche, face du cube et URL source) pour charger les données au bon endroit dans une texture OpenGL.

[deprecated] class Qt3DRender::QTextureImageData

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureImageDataGenerator

Cette classe est obsolète. Nous vous déconseillons vivement de l'utiliser dans du nouveau code.

QTextureImageDataGenerator est un fournisseur de données pour QAbstractTexture. QTextureImageDataGenerator peut être utilisé pour étendre Qt3D en proposant davantage de moyens de charger des données d'images de texture, ainsi que pour prendre en charge des formats définis par l'utilisateur et des formats que Qt3D ne prend pas en charge nativement. Les données sont renvoyées par l’objet ` QTextureImageDataPtr `, qui contient les données qui seront chargées dans la texture. QTextureImageDataGenerator est exécuté par des tâches Aspect en arrière-plan.

[deprecated] class Qt3DRender::QTextureLoader

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du code nouveau.

[deprecated] class Qt3DRender::QTextureRectangle

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QTextureWrapMode

Cette classe est obsolète. Nous vous déconseillons fortement de l'utiliser dans du nouveau code.

[deprecated] class Qt3DRender::QViewport

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Qt3DRender::QViewport La propriété « scene » spécifie la partie de la surface de rendu sur laquelle Qt3D effectue le rendu. La zone située en dehors de la fenêtre d'affichage n'est pas modifiée. Elle contrôle également les paramètres globaux du rendu dans cette fenêtre d'affichage, tels que le gamma.

[deprecated] class Qt3DRender::QWaitFence

Cette classe est obsolète. Nous déconseillons fortement de l'utiliser dans du nouveau code.

Les « fences » permettent de synchroniser les charges de travail du GPU et du CPU. Les commandes GPU sont généralement non bloquantes. Lorsqu'elles sont émises, les commandes sont insérées dans des tampons de commandes qui seront lus ultérieurement par le GPU. Dans certains cas, vous souhaitez poursuivre le traitement ou émettre une commande spécifique uniquement lorsque vous êtes certain qu'une commande a été exécutée par le matériel. Les « fences » constituent un moyen d’y parvenir. Ceci est particulièrement important lors de l’utilisation de moteurs tiers avec Qt3D : Qt3D ne doit accéder aux ressources partagées que lorsque l’on sait que les commandes de l’autre moteur ont fini de modifier la ressource.

QWaitFence est un nœud FrameGraph qui force l’attente de sa signalisation avant que les commandes suivantes ne soient insérées dans le flux de commandes. Il peut alors être utilisé conjointement avec QSetFence et dispose de propriétés permettant de configurer la durée d’attente et de déterminer s’il doit bloquer côté CPU.