QSurfaceFormat Class
La classe QSurfaceFormat représente le format d'une surface QSurface. Plus....
| En-tête : | #include <QSurfaceFormat> |
| CMake : | find_package(Qt6 REQUIRED COMPONENTS Gui)target_link_libraries(mytarget PRIVATE Qt6::Gui) |
| qmake : | QT += gui |
Types publics
| enum | FormatOption { StereoBuffers, DebugContext, DeprecatedFunctions, ResetNotification, ProtectedContent } |
| flags | FormatOptions |
| enum | OpenGLContextProfile { NoProfile, CoreProfile, CompatibilityProfile } |
| enum | RenderableType { DefaultRenderableType, OpenGL, OpenGLES, OpenVG } |
| enum | SwapBehavior { DefaultSwapBehavior, SingleBuffer, DoubleBuffer, TripleBuffer } |
Fonctions publiques
| QSurfaceFormat() | |
| QSurfaceFormat(QSurfaceFormat::FormatOptions options) | |
| QSurfaceFormat(const QSurfaceFormat &other) | |
| ~QSurfaceFormat() | |
| int | alphaBufferSize() const |
| int | blueBufferSize() const |
| const QColorSpace & | colorSpace() const |
| int | depthBufferSize() const |
| int | greenBufferSize() const |
| bool | hasAlpha() const |
| int | majorVersion() const |
| int | minorVersion() const |
| QSurfaceFormat::FormatOptions | options() const |
| QSurfaceFormat::OpenGLContextProfile | profile() const |
| int | redBufferSize() const |
| QSurfaceFormat::RenderableType | renderableType() const |
| int | samples() const |
| void | setAlphaBufferSize(int size) |
| void | setBlueBufferSize(int size) |
(since 6.0) void | setColorSpace(const QColorSpace &colorSpace) |
| void | setDepthBufferSize(int size) |
| void | setGreenBufferSize(int size) |
| void | setMajorVersion(int major) |
| void | setMinorVersion(int minor) |
| void | setOption(QSurfaceFormat::FormatOption option, bool on = true) |
| void | setOptions(QSurfaceFormat::FormatOptions options) |
| void | setProfile(QSurfaceFormat::OpenGLContextProfile profile) |
| void | setRedBufferSize(int size) |
| void | setRenderableType(QSurfaceFormat::RenderableType type) |
| void | setSamples(int numSamples) |
| void | setStencilBufferSize(int size) |
| void | setStereo(bool enable) |
| void | setSwapBehavior(QSurfaceFormat::SwapBehavior behavior) |
| void | setSwapInterval(int interval) |
| void | setVersion(int major, int minor) |
| int | stencilBufferSize() const |
| bool | stereo() const |
| QSurfaceFormat::SwapBehavior | swapBehavior() const |
| int | swapInterval() const |
| bool | testOption(QSurfaceFormat::FormatOption option) const |
| std::pair<int, int> | version() const |
| QSurfaceFormat & | operator=(const QSurfaceFormat &other) |
Membres publics statiques
| QSurfaceFormat | defaultFormat() |
| void | setDefaultFormat(const QSurfaceFormat &format) |
Non-membres apparentés
| bool | operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs) |
| bool | operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs) |
Description détaillée
Le format comprend la taille des tampons de couleur, rouge, vert et bleu, la taille du tampon alpha, la taille des tampons de profondeur et de pochoir, et le nombre d'échantillons par pixel pour le multi-échantillonnage. En outre, le format contient des paramètres de configuration de la surface tels que le profil et la version OpenGL pour le rendu, l'activation ou non des tampons stéréo et le comportement de permutation.
Remarque : lors de la résolution de problèmes liés au contexte ou au format de fenêtre, il peut être utile d'activer la catégorie de journalisation qt.qpa.gl. Selon la plate-forme, cela peut permettre d'imprimer des informations de débogage utiles en ce qui concerne l'initialisation d'OpenGL et les configurations visuelles ou de framebuffer natives auxquelles QSurfaceFormat est mappé.
Documentation des types de membres
enum QSurfaceFormat::FormatOption
flags QSurfaceFormat::FormatOptions
Cette énumération contient des options de format à utiliser avec QSurfaceFormat.
| Constante | Valeur | Description de l'option |
|---|---|---|
QSurfaceFormat::StereoBuffers | 0x0001 | Utilisé pour demander des tampons stéréo au format surface. |
QSurfaceFormat::DebugContext | 0x0002 | Utilisé pour demander un contexte de débogage avec des informations de débogage supplémentaires. |
QSurfaceFormat::DeprecatedFunctions | 0x0004 | Utilisée pour demander que les fonctions dépréciées soient incluses dans le profil du contexte OpenGL. Si cela n'est pas spécifié, vous obtiendrez un contexte compatible avec l'avenir sans prendre en charge les fonctionnalités marquées comme dépréciées. Cela nécessite la version 3.0 ou plus d'OpenGL. |
QSurfaceFormat::ResetNotification | 0x0008 | Active les notifications de réinitialisation du contexte OpenGL. Le statut est alors interrogeable via la fonction isValid() du contexte. Notez que le fait de ne pas activer ce drapeau ne garantit pas que la perte d'état du contexte ne se produise jamais. De plus, certaines implémentations peuvent choisir de signaler la perte de contexte sans tenir compte de cet indicateur. Les plateformes qui prennent en charge l'activation dynamique de la surveillance de la perte de contexte, telles que Windows avec WGL, ou Linux/X11 (xcb) avec GLX, surveilleront l'état à chaque appel à makeCurrent(). Voir isValid() pour plus d'informations à ce sujet. |
QSurfaceFormat::ProtectedContent | 0x0010 | Permet l'accès au contenu protégé. Cela permet au GPU d'opérer sur des ressources protégées (surfaces, tampons, textures), par exemple du contenu vidéo protégé par DRM. Actuellement, cette option n'est mise en œuvre que pour l'EGL. |
Le type FormatOptions est un typedef pour QFlags<FormatOption>. Il stocke une combinaison OU de valeurs FormatOption.
enum QSurfaceFormat::OpenGLContextProfile
Cette énumération est utilisée pour spécifier le profil du contexte OpenGL, en conjonction avec QSurfaceFormat::setMajorVersion() et QSurfaceFormat::setMinorVersion().
Les profils sont exposés dans OpenGL 3.2 et plus, et sont utilisés pour choisir entre un profil de base restreint, et un profil de compatibilité qui peut contenir des fonctionnalités de support obsolètes.
Notez que le profil de base peut encore contenir des fonctionnalités qui sont obsolètes et prévues pour être supprimées dans une version supérieure. Pour accéder aux fonctionnalités obsolètes du profil de base dans la version OpenGL définie, vous pouvez utiliser l'option de format QSurfaceFormat QSurfaceFormat::DeprecatedFunctions .
| Constante | Valeur | Description |
|---|---|---|
QSurfaceFormat::NoProfile | 0 | La version d'OpenGL est inférieure à 3.2. Pour les versions 3.2 et plus récentes, c'est la même chose que CoreProfile. |
QSurfaceFormat::CoreProfile | 1 | Les fonctionnalités obsolètes de la version 3.0 d'OpenGL ne sont pas disponibles. |
QSurfaceFormat::CompatibilityProfile | 2 | Les fonctionnalités des versions antérieures d'OpenGL sont disponibles. |
enum QSurfaceFormat::RenderableType
Cette énumération spécifie le moteur de rendu de la surface.
| Constante | Valeur | Description |
|---|---|---|
QSurfaceFormat::DefaultRenderableType | 0x0 | Méthode de rendu par défaut, non spécifiée |
QSurfaceFormat::OpenGL | 0x1 | Rendu OpenGL de bureau |
QSurfaceFormat::OpenGLES | 0x2 | Rendu OpenGL ES 2.0 |
QSurfaceFormat::OpenVG | 0x4 | Rendu Open Vector Graphics |
enum QSurfaceFormat::SwapBehavior
Cette énumération est utilisée par QSurfaceFormat pour spécifier le comportement d'échange d'une surface. Le comportement de permutation est généralement transparent pour l'application, mais il affecte des facteurs tels que la latence de rendu et le débit.
| Constante | Valeur | Description |
|---|---|---|
QSurfaceFormat::DefaultSwapBehavior | 0 | Comportement de permutation par défaut, non spécifié, de la plateforme. |
QSurfaceFormat::SingleBuffer | 1 | Utilisé pour demander une mise en mémoire tampon unique, ce qui peut entraîner un scintillement lorsque le rendu OpenGL est effectué directement à l'écran sans mémoire tampon intermédiaire hors écran. |
QSurfaceFormat::DoubleBuffer | 2 | C'est typiquement le comportement de permutation par défaut sur les plateformes de bureau, consistant en un tampon arrière et un tampon avant. Le rendu est effectué sur le tampon arrière, puis le tampon arrière et le tampon avant sont échangés, ou le contenu du tampon arrière est copié sur le tampon avant, en fonction de l'implémentation. |
QSurfaceFormat::TripleBuffer | 3 | Ce comportement de permutation est parfois utilisé pour réduire le risque de sauter une image lorsque le taux de rendu suit à peine le taux de rafraîchissement de l'écran. En fonction de la plateforme, il peut également conduire à une utilisation légèrement plus efficace du GPU en raison d'un meilleur comportement de pipelining. La triple mise en mémoire tampon se fait au prix d'une image supplémentaire en termes d'utilisation de la mémoire et de latence, et peut ne pas être prise en charge en fonction de la plateforme sous-jacente. |
Documentation des fonctions membres
QSurfaceFormat::QSurfaceFormat()
Construit un QSurfaceFormat initialisé par défaut.
Note : Par défaut, OpenGL 2.0 est demandé car il offre le plus haut niveau de portabilité entre les plates-formes et les implémentations OpenGL.
QSurfaceFormat::QSurfaceFormat(QSurfaceFormat::FormatOptions options)
Construit un QSurfaceFormat avec le format donné options.
QSurfaceFormat::QSurfaceFormat(const QSurfaceFormat &other)
Construit une copie de other.
[noexcept] QSurfaceFormat::~QSurfaceFormat()
Détruit le site QSurfaceFormat.
int QSurfaceFormat::alphaBufferSize() const
Obtenir la taille en bits du canal alpha du tampon de couleur.
Voir aussi setAlphaBufferSize().
int QSurfaceFormat::blueBufferSize() const
Obtient la taille en bits du canal bleu du tampon de couleur.
Voir aussi setBlueBufferSize().
const QColorSpace &QSurfaceFormat::colorSpace() const
Renvoie l'espace colorimétrique.
Voir aussi setColorSpace().
[static] QSurfaceFormat QSurfaceFormat::defaultFormat()
Renvoie le format de surface global par défaut.
Lorsque setDefaultFormat() n'est pas appelé, il s'agit d'une construction par défaut QSurfaceFormat.
Voir aussi setDefaultFormat().
int QSurfaceFormat::depthBufferSize() const
Renvoie la taille du tampon de profondeur.
Voir aussi setDepthBufferSize().
int QSurfaceFormat::greenBufferSize() const
Obtient la taille en bits du canal vert du tampon de couleur.
Voir aussi setGreenBufferSize().
bool QSurfaceFormat::hasAlpha() const
Renvoie true si la taille du tampon alpha est supérieure à zéro.
Cela signifie que la surface peut être utilisée avec des effets de translucidité par pixel.
int QSurfaceFormat::majorVersion() const
Renvoie la version majeure d'OpenGL.
La version par défaut est 2.0.
Voir aussi setMajorVersion().
int QSurfaceFormat::minorVersion() const
Renvoie la version mineure d'OpenGL.
Voir aussi setMinorVersion().
QSurfaceFormat::FormatOptions QSurfaceFormat::options() const
Renvoie les options de format actuellement définies.
Voir aussi setOption(), setOptions() et testOption().
QSurfaceFormat::OpenGLContextProfile QSurfaceFormat::profile() const
Obtenir le profil de contexte OpenGL configuré.
Ce paramètre est ignoré si la version OpenGL demandée est inférieure à 3.2.
Voir aussi setProfile().
int QSurfaceFormat::redBufferSize() const
Obtenir la taille en bits du canal rouge du tampon de couleur.
Voir aussi setRedBufferSize().
QSurfaceFormat::RenderableType QSurfaceFormat::renderableType() const
Obtient le type de rendu.
Choisit entre OpenGL de bureau, OpenGL ES et OpenVG.
Voir aussi setRenderableType().
int QSurfaceFormat::samples() const
Renvoie le nombre d'échantillons par pixel lorsque le multi-échantillonnage est activé, ou -1 lorsque le multi-échantillonnage est désactivé. La valeur de retour par défaut est -1.
Voir également setSamples().
void QSurfaceFormat::setAlphaBufferSize(int size)
Définit la valeur size en bits du canal alpha du tampon de couleur.
Voir aussi alphaBufferSize().
void QSurfaceFormat::setBlueBufferSize(int size)
Définit la valeur souhaitée size en bits du canal bleu du tampon de couleur.
Voir également blueBufferSize().
[since 6.0] void QSurfaceFormat::setColorSpace(const QColorSpace &colorSpace)
Définit l'adresse colorSpace préférée.
Par exemple, cela permet de demander des fenêtres avec des framebuffers par défaut qui sont compatibles avec sRGB sur les plates-formes qui le supportent.
Remarque : si l'espace colorimétrique demandé n'est pas pris en charge par la plate-forme, la demande est ignorée. Interrogez QSurfaceFormat après la création de la fenêtre pour vérifier si la demande d'espace colorimétrique peut être honorée ou non.
Remarque : ce paramètre détermine si le framebuffer par défaut de la fenêtre est capable d'effectuer des mises à jour et des mélanges dans un espace colorimétrique donné. Il ne modifie pas la sortie des applications en soi. Le code de rendu de l'application devra toujours opter pour les appels OpenGL appropriés pour permettre aux mises à jour et aux mélanges d'être effectués dans l'espace colorimétrique donné au lieu d'utiliser les opérations linéaires standard.
Cette fonction a été introduite dans Qt 6.0.
Voir aussi colorSpace().
[static] void QSurfaceFormat::setDefaultFormat(const QSurfaceFormat &format)
Définit la surface globale par défaut format.
Ce format est utilisé par défaut dans les classes QOpenGLContext, QWindow, QOpenGLWidget et similaires.
Il est toujours possible de le remplacer pour chaque instance en utilisant la fonction setFormat() de la classe en question. Cependant, il est souvent plus pratique de définir le format pour toutes les fenêtres au début de l'application. Cela garantit également un comportement correct dans les cas où des contextes partagés sont nécessaires, car la définition du format via cette fonction garantit que tous les contextes et surfaces, même ceux créés en interne par Qt, utiliseront le même format.
Voir aussi defaultFormat().
void QSurfaceFormat::setDepthBufferSize(int size)
Fixe la taille minimale du tampon de profondeur à size.
Voir aussi depthBufferSize().
void QSurfaceFormat::setGreenBufferSize(int size)
Définit la valeur souhaitée size en bits du canal vert du tampon de couleur.
Voir également greenBufferSize().
void QSurfaceFormat::setMajorVersion(int major)
Définit la version OpenGL souhaitée pour major.
Voir également majorVersion().
void QSurfaceFormat::setMinorVersion(int minor)
Définit la version OpenGL souhaitée pour minor.
La version par défaut est 2.0.
Voir aussi minorVersion().
void QSurfaceFormat::setOption(QSurfaceFormat::FormatOption option, bool on = true)
Définit l'option de format option si on est vrai ; sinon, efface l'option.
Pour vérifier qu'une option a été respectée, comparez le format réel au format demandé après la création de la surface/du contexte.
Voir également setOptions(), options() et testOption().
void QSurfaceFormat::setOptions(QSurfaceFormat::FormatOptions options)
Définit les options de format à options.
Pour vérifier qu'une option a été respectée, comparez le format réel au format demandé après la création de la surface/du contexte.
Voir également options() et testOption().
void QSurfaceFormat::setProfile(QSurfaceFormat::OpenGLContextProfile profile)
Définit le contexte OpenGL souhaité profile.
Ce paramètre est ignoré si la version OpenGL demandée est inférieure à 3.2.
Voir aussi profile().
void QSurfaceFormat::setRedBufferSize(int size)
Définit la valeur souhaitée size en bits du canal rouge du tampon de couleur.
Voir également redBufferSize().
void QSurfaceFormat::setRenderableType(QSurfaceFormat::RenderableType type)
Définit le rendu souhaité type.
Choisit entre OpenGL de bureau, OpenGL ES et OpenVG.
Voir aussi renderableType().
void QSurfaceFormat::setSamples(int numSamples)
Définissez le nombre préféré d'échantillons par pixel lorsque le multi-échantillonnage est activé à numSamples. Par défaut, le multi-échantillonnage est désactivé.
Voir également samples().
void QSurfaceFormat::setStencilBufferSize(int size)
Définit la taille préférée de la mémoire tampon du pochoir à size bits.
Voir également stencilBufferSize().
void QSurfaceFormat::setStereo(bool enable)
Si enable est vrai, il active la mise en mémoire tampon stéréo ; sinon, il la désactive.
La mise en mémoire tampon stéréo est désactivée par défaut.
La mise en mémoire tampon stéréo fournit des mémoires tampons de couleur supplémentaires pour générer des images de l'œil gauche et de l'œil droit.
Voir aussi stereo().
void QSurfaceFormat::setSwapBehavior(QSurfaceFormat::SwapBehavior behavior)
Définir la permutation behavior de la surface.
Le comportement de permutation spécifie si la mise en mémoire tampon simple, double ou triple est souhaitée. La valeur par défaut, DefaultSwapBehavior, correspond au comportement d'échange par défaut de la plate-forme.
Voir également swapBehavior().
void QSurfaceFormat::setSwapInterval(int interval)
Définit l'intervalle de permutation préféré. L'intervalle de permutation spécifie le nombre minimum d'images vidéo affichées avant qu'une permutation de tampon ne se produise. Ceci peut être utilisé pour synchroniser le dessin GL dans une fenêtre avec le rafraîchissement vertical de l'écran.
Une valeur de 0 sur interval désactive la synchronisation du rafraîchissement vertical, tandis qu'une valeur supérieure à 0 active la synchronisation verticale. En fixant interval à une valeur plus élevée, par exemple 10, on obtient 10 retraits verticaux entre chaque changement de tampon.
L'intervalle par défaut est de 1.
Il se peut que la plateforme sous-jacente ne prenne pas en charge la modification de l'intervalle d'échange. Dans ce cas, la demande sera ignorée silencieusement.
Voir également swapInterval().
void QSurfaceFormat::setVersion(int major, int minor)
Définit les versions OpenGL souhaitées pour major et minor.
La version par défaut est 2.0.
Voir aussi version().
int QSurfaceFormat::stencilBufferSize() const
Renvoie la taille du tampon du pochoir en bits.
Voir aussi setStencilBufferSize().
bool QSurfaceFormat::stereo() const
Renvoie true si la mise en mémoire tampon stéréo est activée ; sinon, renvoie false. La mise en mémoire tampon stéréo est désactivée par défaut.
Voir aussi setStereo().
QSurfaceFormat::SwapBehavior QSurfaceFormat::swapBehavior() const
Renvoie le comportement configuré de l'échange.
Voir aussi setSwapBehavior().
int QSurfaceFormat::swapInterval() const
Renvoie l'intervalle d'échange.
Voir aussi setSwapInterval().
bool QSurfaceFormat::testOption(QSurfaceFormat::FormatOption option) const
Retourne vrai si l'option de format option est activée, sinon retourne faux.
Voir aussi options().
std::pair<int, int> QSurfaceFormat::version() const
Retourne une std::paire<int, int> représentant la version OpenGL.
Utile pour les vérifications de version, par exemple format.version() >= std::pair(3, 2)
Voir aussi setVersion().
QSurfaceFormat &QSurfaceFormat::operator=(const QSurfaceFormat &other)
Attribue other à cet objet.
Non-membres apparentés
[noexcept] bool operator!=(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)
Renvoie false si toutes les options des deux objets QSurfaceFormat lhs et rhs sont égales ; sinon, renvoie true.
[noexcept] bool operator==(const QSurfaceFormat &lhs, const QSurfaceFormat &rhs)
Renvoie true si toutes les options des deux objets QSurfaceFormat lhs et rhs sont égales.
© 2026 The Qt Company Ltd. Documentation contributions included herein are the copyrights of their respective owners. The documentation provided herein is licensed under the terms of the GNU Free Documentation License version 1.3 as published by the Free Software Foundation. Qt and respective logos are trademarks of The Qt Company Ltd. in Finland and/or other countries worldwide. All other trademarks are property of their respective owners.