SceneEnvironment QML Type

Vous permet de configurer le rendu d'une scène. En savoir plus...

• Liste de tous les membres, y compris les membres hérités

Propriétés

• antialiasingMode : enumeration
• antialiasingQuality : enumeration
• aoBias : real
• aoDistance : real
• aoDither : bool
• aoEnabled : bool (since 6.5)
• aoSampleRate : int
• aoSoftness : real
• aoStrength : real
• backgroundMode : enumeration
• clearColor : color
• debugSettings : QtQuick3D::DebugSettings (since 6.5)
• depthPrePassEnabled : bool
• depthTestEnabled : bool
• effects : List<QtQuick3D::Effect>
• fog : QtQuick3D::Fog (since 6.5)
• lightProbe : QtQuick3D::Texture
• lightmapper : Lightmapper
• oitMethod : enumeration (since 6.11)
• probeExposure : real
• probeHorizon : real
• probeOrientation : vector3d
• scissorRect : rect (since 6.5)
• skyBoxCubeMap : QtQuick3D::CubeMapTexture (since 6.4)
• skyMaterial : QtQuick3D::SkyMaterial (since 6.12)
• skyboxBlurAmount : real (since 6.4)
• specularAAEnabled : bool (since 6.4)
• temporalAAEnabled : bool
• temporalAAMode : enumeration (since 6.11)
• temporalAAStrength : real
• tonemapMode : enumeration (since 6.0)

Description détaillée

SceneEnvironment définit un ensemble de propriétés globales régissant la manière dont une scène doit être rendue.

Pour utiliser SceneEnvironment ou ExtendedSceneEnvironment, associez l'environment property d'un View3D à une instance de ces types. L'objet peut être déclaré en ligne, par exemple comme ceci :

View3D {
    environment: SceneEnvironment {
        antialiasingMode: SceneEnvironment.MSAA
        tonemapMode: SceneEnvironment.TonemapModeFilmic
        backgroundMode: SceneEnvironment.SkyBox
        lightProbe: Texture {
            source: "panoramic_hdri_background.hdr"
        }
    }
}

Il est également possible de définir l'objet d'environnement séparément. Il peut alors être référencé par un ou plusieurs objets ` View3D `. Voici un exemple de fragment de code, utilisant cette fois-ci ` ExtendedSceneEnvironment ` :

ExtendedSceneEnvironment {
    id: myEnv
    vignetteEnabled: true
}

View3D {
    width: parent.width / 2
    environment: myEnv
}

View3D {
    width: parent.width / 2
    x: parent.width / 2
    environment: myEnv
}

Présentation des fonctionnalités

• Paramètres d'anti-aliasing. Consultez les meilleures pratiques en matière d'anti-aliasing pour obtenir un aperçu de ce sujet. Les propriétés concernées sont antialiasingMode, antialiasingQuality, specularAAEnabled, temporalAAEnabled et temporalAAStrength. De plus, si ExtendedSceneEnvironment est utilisé, une autre méthode est disponible via fxaaEnabled.
• Occlusion ambiante dans l’espace écran. Les propriétés concernées sont aoEnabled, aoStrength, aoBias, aoDistance, aoDither, aoSampleRate, aoSoftness. Notez que SSGI fournit également une occlusion ambiante et qu’elle donnera souvent des résultats de meilleure qualité, même si cela peut entraîner un coût plus élevé en termes de performances. Évitez d’activer simultanément l’occlusion ambiante de SceneEnvironment et la SSGI d’ ExtendedSceneEnvironment.
• Couleur de fond, skybox, éclairage basé sur des images (IBL). Pour plus d’informations sur l’IBL, consultez la section « Utilisation de l’éclairage basé sur des images ». Les propriétés concernées sont backgroundMode, clearColor, lightProbe, probeExposure, probeHorizon, probeOrientation, skyboxBlurAmount, skyBoxCubeMap.
• Mappage des tons. tonemapMode permet de configurer la méthode de mappage des tons utilisée pour convertir les valeurs de couleur à plage dynamique élevée en une plage comprise entre 0 et 1 à la fin du pipeline graphique. ExtendedSceneEnvironment propose quelques propriétés supplémentaires, telles que whitePoint et sharpnessAmount, qui peuvent être utilisées pour affiner les calculs de mappage des tons.
• Paramètres du tampon de profondeur. Les propriétés concernées sont depthPrePassEnabled et depthTestEnabled.
• Effets de post-traitement. Outre les effets de post-traitement intégrés fournis par ExtendedSceneEnvironment, les applications peuvent proposer leurs propres effets personnalisés via le type Effect. La propriété effects est une liste d’instances de Effect.
• Paramètres de visualisation de débogage, tels que le mode filaire ou le rendu de certaines contributions de couleur uniquement pour les matériaux. Ces paramètres sont contrôlés par l’objet ` DebugSettings ` référencé par la propriété ` debugSettings `. La plupart de ces paramètres peuvent également être contrôlés de manière interactive lorsqu’un élément ` DebugView ` est ajouté à la scène.
• Paramètres de brouillard. Pour activer le brouillard, définissez un objet ` Fog ` correctement configuré dans la propriété ` fog `.
• Paramètres de cuisson des lightmaps. Lorsque des lightmaps précuites sont utilisées pour certains modèles de la scène, l’objet Lightmapper défini dans la propriété lightmapper détermine les paramètres utilisés pendant le processus de cuisson.
• Paramètres de décalage. Pour appliquer un décalage différent de celui de la fenêtre d'affichage, définissez la propriété scissorRect.

Voir également ExtendedSceneEnvironment.

Documentation sur les propriétés

antialiasingMode : enumeration

Cette propriété contrôle le mode d'anticrénelage appliqué lors du rendu de la scène.

Les valeurs possibles sont :

La valeur par défaut est « SceneEnvironment.NoAA ».

Suréchantillonnage

La scène est rendue dans une résolution supérieure, puis redimensionnée à la résolution réelle.

Avantages: haute qualité. Anticrénelage de l'ensemble du contenu de la scène, et pas seulement des silhouettes géométriques.

Inconvénients: généralement plus gourmand en ressources que le MSAA. Augmente l’utilisation de la mémoire vidéo. Pris en charge avec les éléments View3D pour tous les modes de rendu (renderMode) sauf « Inline », mais comme cette technique implique de rendre d’abord sur une texture, l’activation du SSAA avec un mode de rendu « Underlay » ou « Overlay » entraînera l’utilisation d’une texture intermédiaire et d’un passage de rendu qui ne seraient normalement pas nécessaires, ce qui signifie que les pertes de performances pourraient être plus perceptibles. Il est recommandé de n'utiliser le SSAA que lorsque le renderMode est réglé par défaut sur « Offscreen ».

Multisampling

Les arêtes de la géométrie sont suréchantillonnées, ce qui donne des silhouettes plus lisses. Cette technique n’a toutefois aucun effet sur les matériaux à l’intérieur de la géométrie.

Avantages: fonctionne avec n’importe quel élément « View3D », quel que soit le `renderMode`. Donne de bons résultats sur les contours de la géométrie, là où l’aliasing est souvent le plus visible ; fonctionne sans problème avec des animations rapides. Les performances dépendent uniquement des capacités du système (GPU).

Inconvénients: ne résout pas les problèmes liés aux textures ou aux reflets. Augmente l’utilisation de la mémoire vidéo. Son utilisation peut s’avérer coûteuse sur du matériel graphique moins puissant. Peut être contrôlé au cas par cas pour chaque fenêtre ou pour des éléments d’ View3D individuels, selon le mode de rendu (renderMode). Lorsque l’on utilise les modes « Underlay »/« Overlay » avec un effet appliqué ou le mode « Offscreen », le MSAA peut être contrôlé pour chaque élément d’ View3D. En revanche, l’utilisation d’Underlay/Overlay sans aucun effet ou du mode Inline entraînera un contrôle du MSAA au niveau de chaque fenêtre.

Anticrénelage progressif

Cette propriété active et définit le niveau d’anticrénelage progressif appliqué à la scène.

Lorsque tout le contenu de la scène a cessé de bouger, la caméra est très légèrement agitée d'une image à l'autre, et le résultat de chaque nouvelle image est fusionné avec les images précédentes. Plus vous accumulez d'images, plus le résultat est esthétique.

Avantages: offre d’excellents résultats lorsque tout le contenu de la scène est immobile.

Inconvénients: ne fonctionne pas si des changements visuels se produisent. Coûteux en ressources, car il nécessite une accumulation et un mélange des images. Augmente l’utilisation de la mémoire vidéo.

Consultez les « Bonnes pratiques en matière d’anticrénelage » pour plus d’informations sur les méthodes d’anticrénelage.

antialiasingQuality : enumeration

Cette propriété définit le niveau d'anticrénelage appliqué à la scène. Son comportement dépend de la valeur attribuée à la propriété « antialiasingMode ». Lorsque la propriété « antialiasingMode » est définie sur « NoAA », cette propriété n'a aucun effet.

Les valeurs possibles sont :

La valeur par défaut est SceneEnvironment.High

aoBias : real

Cette propriété définit une distance de coupure empêchant les objets de présenter un effet d'occlusion ambiante à courte distance. Des valeurs plus élevées augmentent la distance nécessaire entre les objets avant que l'occlusion ambiante ne soit visible.

La valeur par défaut est 0,0.

aoDistance : real

Cette propriété définit approximativement la distance à laquelle les ombres d'occlusion ambiante s'étendent à partir des objets. Plus cette distance est grande, plus l'impact sur les performances est important.

La valeur par défaut est 5,0.

Illustration ci-contre avec la valeur par défaut « aoSoftness » et la valeur maximale « aoStrength » :

Voir également aoStrength et aoSoftness.

aoDither : bool

Lorsque cette propriété est activée, elle diffuse les contours des bandes d'ombre de l'occlusion ambiante afin d'améliorer la fluidité (au risque de produire parfois des artefacts à motifs visibles).

La valeur par défaut est « false ».

Voir également « PerspectiveCamera.clipFar » et « OrthographicCamera.clipFar ».

aoEnabled : bool [since 6.5]

Activer ou désactiver l'occlusion ambiante.

La valeur par défaut est « false », ce qui signifie que l'occlusion ambiante est désactivée.

Cette propriété a été introduite dans Qt 6.5.

Voir également aoStrength et aoDistance.

aoSampleRate : int

Cette propriété définit la qualité de l'occlusion ambiante (davantage de nuances de gris) au détriment des performances.

La valeur doit être 2, 3 ou 4. La valeur par défaut est 2.

aoSoftness : real

Cette propriété définit le degré de lissage des contours de l'ombrage par occlusion ambiante.

La valeur doit être comprise entre 0,0 et 50,0. La valeur par défaut est 50,0.

Illustration ci-contre avec la valeur par défaut « aoDistance » et la valeur maximale « aoStrength » :

Voir également aoStrength et aoDistance.

aoStrength : real

Cette propriété définit l'intensité de l'occlusion ambiante appliquée. L'occlusion ambiante est une forme d'éclairage global approximatif qui génère des auto-ombres non directionnelles lorsque les objets sont proches les uns des autres. Une valeur de 100 produit des ombres totalement sombres ; des valeurs plus faibles rendent les ombres plus claires. Une valeur de 0 désactive complètement l'occlusion ambiante, ce qui améliore les performances au détriment du réalisme visuel des objets 3D rendus dans la scène.

Toutes les valeurs autres que 0 ont le même impact sur les performances.

La valeur par défaut est 0,0. La valeur maximale est 100,0.

Une valeur de 0 équivaut à définir « aoEnabled » sur « false ».

Illustration ci-contre avec les paramètres par défaut de l’ aoSoftness et de l’ aoDistance:

Voir également aoEnabled, aoDistance et aoSoftness.

backgroundMode : enumeration

Cette propriété détermine si et comment l'arrière-plan de la scène doit être effacé.

La valeur par défaut est SceneEnvironment.Transparent

Prenons l’exemple suivant. Le modèle Suzanne est censé avoir été pré-traité avec l’outil balsam et provient du référentiel glTF Sample Models.

import QtQuick
import QtQuick3D
import QtQuick3D.Helpers

Item {
    width: 1280
    height: 720

    View3D {
        id: v3d
        anchors.fill: parent

        environment: ExtendedSceneEnvironment {
            backgroundMode: SceneEnvironment.SkyBox
            lightProbe: Texture { source: "00455_OpenfootageNET_field_low.hdr" }

            glowEnabled: true
            glowStrength: 1.25
            glowBloom: 0.25
            glowBlendMode: ExtendedSceneEnvironment.GlowBlendMode.Additive
        }

        DirectionalLight {
        }

        Suzanne {
            scale: Qt.vector3d(50, 50, 50)
            z: -500
        }

        PerspectiveCamera {
            id: camera
        }

        WasdController {
            controlledObject: camera
        }
    }
}

L'utilisation d'un éclairage basé sur des images en plus de l'DirectionalLight, ainsi que l'utilisation de la texture de sonde de lumière comme skybox, donne le résultat suivant :

Que se passe-t-il s’il n’y a pas de sonde de lumière ?

backgroundMode: SceneEnvironment.Transparent

Ici, l’arrière-plan n’est pas fourni par View3D, mais par QQuickWindow ou QQuickView, qui hébergent la scène 2D et 3D. L’éclairage repose uniquement sur DirectionalLight.

Utilisation d’une couleur transparente fixe :

backgroundMode: SceneEnvironment.Color
clearColor: "green"

Voir également lightProbe, QQuickWindow::setColor(), Window::color et View3D.

clearColor : color

Cette propriété définit la couleur qui sera utilisée pour effacer la fenêtre d'affichage lorsque l'on utilise « SceneEnvironment.Color » pour la propriété « backgroundMode ».

La valeur par défaut est Qt::black

Voir également backgroundMode.

debugSettings : QtQuick3D::DebugSettings [since 6.5]

Cette propriété spécifie un objet ` DebugSettings ` utilisé pour configurer les outils de débogage du moteur de rendu. Lors de sa création, l’ SceneEnvironment crée automatiquement un objet ` DebugSettings ` qui lui est associé ; il n’est donc généralement pas nécessaire de définir un objet ` DebugSettings ` personnalisé.

Exemple de rendu de la scène avec le mode filaire activé :

Visualisation des vecteurs normaux des maillages :

Visualisation de la contribution de l’éclairage spéculaire :

Cette propriété a été introduite dans Qt 6.5.

Voir également DebugSettings.

depthPrePassEnabled : bool

Lorsqu'elle est activée, la moteur de rendu effectue un « Z-prepass » pour les objets opaques, ce qui signifie qu'il les rend à l'aide d'un shader simple, avec l'écriture de couleur désactivée, afin de préremplir le tampon de profondeur avant d'émettre les appels de dessin pour les passes de rendu principales.

Cela peut améliorer les performances en fonction du contenu de la scène. Ce sont généralement les scènes comportant de nombreux objets qui se chevauchent et un shading de fragments coûteux qui en tirent profit. Par ailleurs, il convient de noter que le moteur de rendu effectue un tri de l'avant vers l'arrière pour les objets opaques, ce qui contribue en soi à réduire le shading de fragments inutile ; par conséquent, le pré-pass Z n'apporte pas toujours des améliorations significatives.

Sur les GPU utilisant une architecture de rendu en mosaïque, courante dans les systèmes mobiles et embarqués, il est recommandé de définir cette option sur ` false`.

La valeur par défaut est « false ».

depthTestEnabled : bool

La valeur par défaut est true. Par défaut, le moteur de rendu classe les objets de la scène soit dans la liste « opaque », soit dans la liste « semi-transparent ». Les objets (sous-maillages avec le matériau associé) figurant dans la liste « opaque » sont rendus en premier, avec le test de profondeur et l'écriture de profondeur activés, ce qui permet un culling Z optimal pour les objets 3D classiques ne comportant pas de zones semi-transparentes. Les objets de la liste semi-transparent sont rendus avec l’écriture de profondeur désactivée, mais toujours avec le test de profondeur activé (pour effectuer une comparaison avec les objets opaques), dans l’ordre de l’arrière vers l’avant (triés en fonction de la distance entre leur point central et la caméra). Cela permet un mélange correct (« transparence ») pour les objets 3D comportant des zones semi-transparentes à leur surface, que ce soit en raison de l’ node opacity, ou d’une carte de couleur ou de texture dans le matériau.

Lorsque cette propriété est définie sur « false », le tampon Z n’est ni écrit ni utilisé pour le test de profondeur, le test de profondeur est ignoré, et tous les objets, y compris ceux qui sont entièrement opaques, sont rendus en une seule fois, triés de l’arrière vers l’avant.

Il est rarement nécessaire de définir cette propriété sur « false ». Cela peut s’avérer utile dans des scènes où l’on sait que l’approche en deux passes n’apporte que peu d’avantages, soit parce qu’il y a très peu d’objets opaques, soit parce qu’ils sont transformés de telle manière qu’un seul passage trié de l’arrière vers l’avant offre de meilleures performances.

effects : List<QtQuick3D::Effect>

Cette propriété contient une liste d'effets de post-traitement qui seront appliqués à l'ensemble de la fenêtre d'affichage. Le résultat de chaque effet est transmis à l'effet suivant ; l'ordre dans lequel ils sont définis est donc important.

fog : QtQuick3D::Fog [since 6.5]

Lorsque cette propriété est définie sur un objet ` Fog ` valide, elle sert à configurer la prise en charge intégrée du brouillard par le moteur de rendu.

La valeur par défaut est null, ce qui signifie qu’il n’y a pas de brouillard. Cela revient à définir un objet Fog dont la propriété enabled est définie sur false.

Cette propriété a été introduite dans Qt 6.5.

Voir également Fog.

lightProbe : QtQuick3D::Texture

Cette propriété définit une image utilisée pour éclairer la scène, soit à la place des lumières standard, soit en complément de celles-ci.

L'image est de préférence une image à plage dynamique élevée (HDR) ou une carte cubique (cubemap) pré-générée. Le pré-calcul (pre-baking) apporte des gains de performances significatifs lors de l'exécution, car il n'y a pas de temps consacré au filtrage et à la génération de mipmaps. Si la source est un fichier .hdr ou une autre image, le prétraitement par le GPU s'effectue au moment de l'exécution après le chargement du fichier image, ce qui peut s'avérer chronophage, en particulier sur du matériel embarqué et mobile. Il est donc fortement recommandé que les applications prétraitent les images .hdr au plus tard au moment de la compilation, comme décrit ici.

Pour plus d’informations sur l’éclairage basé sur des images, consultez la section « Utilisation de l’éclairage basé sur des images ».

Les exemples ci-dessous ont été générés en faisant varier l'backgroundMode dans l'environnement de la scène suivante. La scène ne comporte ni DirectionLight, ni PointLight, ni SpotLight. Tout l'éclairage repose sur l'image HDRI panoramique.

import QtQuick
import QtQuick3D
import QtQuick3D.Helpers

Item {
    width: 1280
    height: 720

    View3D {
        id: v3d
        anchors.fill: parent

        environment: ExtendedSceneEnvironment {
            backgroundMode: SceneEnvironment.SkyBox
            lightProbe: Texture { source: "00455_OpenfootageNET_field_low.hdr" }

            tonemapMode: SceneEnvironment.TonemapModeFilmic
            sharpnessAmount: 0.4

            glowEnabled: true
            glowStrength: 1.25
            glowBloom: 0.25
            glowBlendMode: ExtendedSceneEnvironment.GlowBlendMode.Additive
        }

        Node {
            scale: Qt.vector3d(100, 100, 100)

            Sponza {
            }

            Suzanne {
                y: 1
                scale: Qt.vector3d(0.5, 0.5, 0.5)
                eulerRotation.y: -90
            }
        }

        PerspectiveCamera {
            id: camera
            y: 100
        }

        WasdController {
            controlledObject: camera
        }
    }
}

Résultats avec l’environnement ci-dessus :

En remplaçant l’ backgroundMode par SceneEnvironment.Transparent, on obtient :

Ici, l'éclairage de la scène 3D est identique à celui de la scène précédente, ce qui signifie que les matériaux utilisent la sonde de lumière dans les calculs d'éclairage de la même manière qu’auparavant, mais qu’aucun skybox n’est rendu. L’arrière-plan est blanc, car il s’agit de la couleur de transparence par défaut de l’ QQuickWindow hébergeant les scènes 2D et 3D.

Il est possible de rétablir la valeur par défaut (null) de la propriété lightProbe. Cela désassigne la texture précédemment associée. Par exemple, utilisons la touche Suppr pour basculer dynamiquement entre un éclairage basé sur une image avec une skybox et l’absence d’éclairage basé sur une image avec une couleur de fond fixe :

environment: ExtendedSceneEnvironment {
    id: env

    backgroundMode: SceneEnvironment.SkyBox
    lightProbe: iblTex

    tonemapMode: SceneEnvironment.TonemapModeFilmic
    sharpnessAmount: 0.4

    glowEnabled: true
    glowStrength: 1.25
    glowBloom: 0.25
    glowBlendMode: ExtendedSceneEnvironment.GlowBlendMode.Additive
}

Texture {
    id: iblTex
    source: "00455_OpenfootageNET_field_low.hdr"
}

focus: true
Keys.onDeletePressed: {
    if (env.backgroundMode == SceneEnvironment.SkyBox) {
        env.backgroundMode = SceneEnvironment.Color;
        env.clearColor = "green";
        env.lightProbe = null;
    } else {
        env.backgroundMode = SceneEnvironment.SkyBox;
        env.lightProbe = iblTex;
    }
}

Appuyer sur la touche Suppr donne le résultat suivant. N’oubliez pas que la scène utilisée ici ne comporte aucune lumière ; tous les modèles 3D apparaissent donc entièrement noirs.

Bien que `lightProbe` soit couramment utilisé en combinaison avec des instances de texture qui tirent leurs données d’un fichier image (généralement .hdr ou .ktx), il peut également être pertinent de l’associer à une texture utilisant des données en mémoire, procedurally generated image data. Un excellent exemple en est une texture dont les données d’image sont générées par ProceduralSkyTextureData à partir du module QtQuick3D.Helpers :

backgroundMode: SceneEnvironment.SkyBox
lightProbe: Texture {
    textureData: ProceduralSkyTextureData {
    }
}

Cela nous donne une texture de skybox HDR générée de manière procédurale, qui est désormais utilisée à la fois comme skybox et pour l’éclairage basé sur l’image :

Voir également backgroundMode, « Using Image-Based Lighting », « Pre-generating IBL cubemap », probeExposure, probeHorizon, probeOrientation, et ProceduralSkyTextureData.

lightmapper : Lightmapper

Lorsque cette propriété est définie sur un objet Lightmapper valide, les paramètres spécifiés par cet objet seront pris en compte lors de la création des lightmaps.

La valeur par défaut est null, ce qui signifie que les valeurs par défaut seront utilisées pour tous les paramètres liés à la création des lightmaps.

Pour plus d’informations sur la création de lightmaps, consultez la documentation d’ Lightmapper.

Lorsque les lightmaps ne sont pas pertinentes pour une application et qu’aucun éclairage cuit n’est jamais généré, la propriété et l’objet associé n’ont aucune utilité dans la pratique.

Voir également Model::usedInBakedLighting, Model::bakedLightmap, Light::bakeMode et Lightmapper.

oitMethod : enumeration [since 6.11]

Cette propriété définit la méthode de transparence indépendante de l'ordre (OIT). En attribuant à cette propriété une méthode OIT valide, le moteur de rendu affiche les pixels transparents dans le bon ordre de profondeur.

Les valeurs possibles sont :

Par défaut, la transparence est de type « None » et la transparence indépendante de l'ordre est désactivée.

Mélangepondéré

Il s’agit d’une approximation de la transparence indépendante de l’ordre. Les fragments transparents sont rendus dans un tampon hors écran tandis qu’une pondération est appliquée à chaque fragment en fonction de sa distance par rapport à la caméra. Ce tampon est ensuite fusionné avec le tampon arrière après suppression de la pondération de chaque pixel. Cette méthode ne respecte pas la règle de composition « source-over » pour tous les fragments et le résultat diffère du résultat correct ; toutefois, elle fonctionne également sur du matériel plus ancien et est plus rapide que les autres méthodes plus rigoureuses.

Listechaînée

Il s'agit d'une transparence indépendante de l'ordre précise. Les fragments transparents sont rendus dans une liste chaînée lors de la passe de rendu, triés en fonction de leur profondeur, puis fusionnés lors de la passe de composition.

Cette propriété a été introduite dans Qt 6.11.

probeExposure : real

Cette propriété modifie la quantité de lumière émise par la sonde lumineuse. Le mappage des tons comprend notamment le mappage de l'exposition, et cette propriété permet d'ajuster la manière dont les valeurs de lumière des sondes lumineuses sont mappées.

Par défaut, l'exposition est réglée sur 1,0

Voir également « lightProbe », « probeHorizon » et « probeOrientation ».

probeHorizon : real

Lorsque cette propriété est définie avec des valeurs croissantes, elle assombrit (noircit) la moitié inférieure de l'environnement, ce qui oblige l'éclairage à provenir principalement du haut de l'image (et supprime certains reflets de la moitié inférieure). Cette propriété est utile pour tenir compte d'un plan de sol qui aurait pour effet d'occulter le reflet de la sonde lumineuse au niveau du sol. Cela est nécessaire car les contributions des sondes de lumière proviennent directement de l’image sans tenir compte du contenu de la scène.

La plage de valeurs attendue pour la propriété probeHorizon est comprise entre 0,0 et 1,0. Toute valeur en dehors de cette plage sera limitée à la plage attendue.

Par défaut, probeHorizon est défini sur 0,0, ce qui signifie que la sonde lumineuse est utilisée dans son intégralité, sans ajustement.

Voir également lightProbe, probeExposure et probeOrientation.

probeOrientation : vector3d

Cette propriété définit l'orientation de la sonde lumineuse. L'orientation est exprimée en angles d'Euler, en degrés, par rapport aux axes x, y et z.

Voir également « lightProbe », « probeHorizon » et « probeExposure ».

scissorRect : rect [since 6.5]

Cette propriété définit un rectangle de découpe dans les coordonnées de la vue, dont le coin supérieur gauche se trouve en [0, 0]

Cette propriété a été introduite dans Qt 6.5.

skyBoxCubeMap : QtQuick3D::CubeMapTexture [since 6.4]

Cette propriété définit une carte cubique (cubemap) à utiliser comme skybox lorsque le mode d'arrière-plan est « SkyBoxCubeMap ».

Cette propriété a été introduite dans Qt 6.4.

skyMaterial : QtQuick3D::SkyMaterial [since 6.12]

Cette propriété définit un modèle de ciel procédural, généré par le GPU, utilisé pour l'IBL et comme arrière-plan de la scène.

Cette propriété a été introduite dans Qt 6.12.

Voir également backgroundMode et lightProbe.

skyboxBlurAmount : real [since 6.4]

Cette propriété détermine le degré de flou à appliquer à la skybox lorsque l'on utilise l'option « SceneEnvironment.SkyBox » pour la propriété « backgroundMode ». La valeur par défaut est « 0.0 », ce qui signifie qu'il n'y a pas de flou.

Les valeurs acceptables sont comprises entre 0,0 et 1,0 ; toutes les autres valeurs seront limitées à cette plage.

Cette propriété a été introduite dans Qt 6.4.

specularAAEnabled : bool [since 6.4]

Lorsque cette option est activée, l'aliasing spéculaire est atténué. L'aliasing spéculaire se manifeste souvent sous la forme de points lumineux, pouvant scintiller lorsque l'on déplace la caméra.

La valeur par défaut est « false ».

Cette propriété a été introduite dans Qt 6.4.

temporalAAEnabled : bool [default: false]

Lorsque cette option est activée, l'anticrénelage temporel sera utilisé.

La caméra est très légèrement déplacée d'une image à l'autre, et le résultat de chaque nouvelle image est fusionné avec celui de l'image précédente.

Avantages: grâce au mouvement saccadé de la caméra, il permet de révéler des détails qui auraient autrement été perdus ; faible impact sur les performances.

Inconvénients: les objets se déplaçant rapidement provoquent un effet de fantôme sur une image.

temporalAAMode : enumeration [since 6.11]

Permet de contrôler le mode d'anti-aliasing temporel. L'anti-aliasing temporel réduit le scintillement et l'aliasing en fusionnant les informations de plusieurs images.

La valeur par défaut est « SceneEnvironment.TAADefault ».

Cette propriété a été introduite dans Qt 6.11.

temporalAAStrength : real [default: 0.3]

Cette propriété modifie l'amplitude du mouvement temporel (anticrénelage). Elle n'a d'effet que lorsque la propriété ` temporalAAEnabled ` est définie sur `true`.

Voir également temporalAAEnabled.

tonemapMode : enumeration [since 6.0]

Cette propriété définit la manière dont les couleurs sont soumises à un mappage de tons avant le rendu. Tous les rendus dans Qt Quick 3D sont effectués dans un espace colorimétrique linéaire, ce qui peut souvent entraîner la génération de valeurs de couleur non affichables. Le paramètre `tonemapMode` détermine la technique utilisée pour remapper les couleurs dans une plage affichable.

La valeur par défaut est SceneEnvironment.TonemapModeLinear

Consultez ExtendedSceneEnvironment pour voir un exemple de ces différents modes.

Cette propriété a été introduite dans Qt 6.0.