QOpenGLTexture Class

// Prepare texture
QOpenGLTexture *texture = new QOpenGLTexture(QImage(fileName).flipped());
texture->setMinificationFilter(QOpenGLTexture::LinearMipMapLinear);
texture->setMagnificationFilter(QOpenGLTexture::Linear);
...
// Render with texture
texture->bind();
glDrawArrays(...);

Documentation des fonctions membres

[explicit] QOpenGLTexture::QOpenGLTexture(QOpenGLTexture::Target target)

Crée un objet `QOpenGLTexture` qui pourra ensuite être lié à ` target`.

Cela ne crée pas l'objet de texture OpenGL sous-jacent. Par conséquent, la construction à l'aide de ce constructeur ne nécessite pas de contexte OpenGL valide.

[explicit] QOpenGLTexture::QOpenGLTexture(const QImage &image, QOpenGLTexture::MipMapGeneration genMipMaps = GenerateMipMaps)

Crée un objet `QOpenGLTexture` qui pourra ensuite être lié à la cible de texture 2D et qui contient les données de pixels présentes dans ` image`. Si vous souhaitez générer une chaîne de mipmaps, définissez ` genMipMaps ` sur ` true ` (c'est la valeur par défaut).

Cette opération crée l'objet de texture OpenGL sous-jacent. Par conséquent, la construction à l'aide de ce constructeur nécessite un contexte OpenGL valide et actif.

void QOpenGLTexture::allocateStorage()

Alloue de l'espace de stockage côté serveur à cet objet de texture en tenant compte du format, des dimensions, des niveaux de mipmap, des couches de tableau et des faces de cubemap.

Une fois l'espace de stockage alloué, il n'est plus possible de modifier ces propriétés.

Si cette fonctionnalité est prise en charge, la méthode ` QOpenGLTexture ` utilise un stockage de texture immuable.

Une fois l’espace de stockage alloué à la texture, les données de pixels peuvent être chargées via l’une des surcharges de la méthode ` setData()`.

Voir également ` isStorageAllocated()` et ` setData()`.

void QOpenGLTexture::allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)

Alloue de l'espace de stockage côté serveur pour cet objet de texture en tenant compte du format, des dimensions, des niveaux de mipmap, des couches de tableau et des faces de la carte cubique.

Une fois l'espace de stockage alloué, il n'est plus possible de modifier ces propriétés.

Si la fonctionnalité est prise en charge, ` QOpenGLTexture ` utilise un stockage de texture immuable. Toutefois, si le stockage de texture immuable n’est pas disponible, les paramètres ` pixelFormat ` et ` pixelType ` spécifiés seront utilisés pour allouer un stockage mutable ; notez que dans certaines implémentations d’OpenGL (notamment OpenGL ES 2), ils doivent correspondre parfaitement au format et au type passés à tout appel ultérieur à ` setData()`.

Une fois l'espace mémoire alloué pour la texture, les données de pixels peuvent être chargées via l'une des surcharges de la fonction ` setData()`.

Voir également ` isStorageAllocated()` et ` setData()`.

void QOpenGLTexture::bind()

Lie cette texture à l'unité de texture actuellement active, prête pour le rendu. Notez qu'il n'est pas nécessaire de lier les objets de type ` QOpenGLTexture ` pour les modifier, car l'implémentation utilise l'extension EXT_direct_state_access lorsqu'elle est disponible et la simule lorsqu'elle ne l'est pas.

Voir également release().

void QOpenGLTexture::bind(uint unit, QOpenGLTexture::TextureUnitReset reset = DontResetTextureUnit)

Lie cette texture à l'unité de texture unit afin qu'elle soit prête pour le rendu. Notez qu'il n'est pas nécessaire de lier les objets QOpenGLTexture pour les modifier, car l'implémentation utilise l'extension EXT_direct_state_access lorsqu'elle est disponible et la simule lorsqu'elle ne l'est pas.

Si le paramètre reset est true, cette fonction rétablit l’unité active à l’unité de texture qui était active au moment de l’appel.

Voir également release().

QColor QOpenGLTexture::borderColor() const

Renvoie la couleur de la bordure (borderColor) de cette texture.

Voir aussi setBorderColor().

void QOpenGLTexture::borderColor(float *border) const

Écrit la couleur de la bordure de la texture dans les quatre premiers éléments du tableau pointé par border.

Voir également setBorderColor().

void QOpenGLTexture::borderColor(int *border) const

Écrit la couleur de la bordure de la texture dans les quatre premiers éléments du tableau pointé par ` border`.

void QOpenGLTexture::borderColor(unsigned int *border) const

Écrit la couleur de la bordure de la texture dans les quatre premiers éléments du tableau pointé par ` border`.

[static] GLuint QOpenGLTexture::boundTextureId(QOpenGLTexture::BindingTarget target)

Renvoie l'textureId e de la texture associée à l'target de l'unité de texture actuellement active.

[static] GLuint QOpenGLTexture::boundTextureId(uint unit, QOpenGLTexture::BindingTarget target)

Renvoie l'textureId e de la texture liée à l'target e de l'unité de texture unit.

QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const

Renvoie l'opérateur de comparaison défini pour cette texture. Par défaut, une texture utilise la fonction de comparaison « CompareLessEqual ».

Voir aussi setComparisonFunction().

QOpenGLTexture::ComparisonMode QOpenGLTexture::comparisonMode() const

Renvoie le mode de comparaison défini pour cette texture. Par défaut, une texture utilise le mode de comparaison « CompareNone » (c'est-à-dire que les comparaisons sont désactivées).

Voir également setComparisonMode().

bool QOpenGLTexture::create()

Crée l'objet de texture OpenGL sous-jacent. Cela nécessite un contexte OpenGL valide et actif. Si l'objet de texture existe déjà, cette fonction ne fait rien.

Une fois l'objet de texture créé, vous pouvez obtenir son nom à l'aide de la fonction ` textureId()`. Cela peut s'avérer utile si vous souhaitez effectuer des appels OpenGL bruts liés à cette texture.

Normalement, il ne devrait pas être nécessaire d’appeler cette fonction directement, car toutes les fonctions qui définissent les propriétés de l’objet texture appellent implicitement create() à votre place.

Renvoie ` true ` si la création a réussi, sinon renvoie ` false`.

Voir également destroy(), isCreated() et textureId().

QOpenGLTexture *QOpenGLTexture::createTextureView(QOpenGLTexture::Target target, QOpenGLTexture::TextureFormat viewFormat, int minimumMipmapLevel, int maximumMipmapLevel, int minimumLayer, int maximumLayer) const

Tente de créer une vue de texture sur cette texture. Une vue de texture s'apparente en quelque sorte à une vue en SQL, dans la mesure où elle présente une vue restreinte ou réinterprétée des données d'origine. Les vues de texture n'allouent pas d'espace de stockage supplémentaire côté serveur, mais s'appuient sur le tampon de stockage de la texture source.

Les vues de texture ne sont disponibles que lors de l’utilisation d’un stockage immuable. Pour plus d’informations sur les vues de texture, consultez http://www.opengl.org/wiki/Texture_Storage#Texture_views.

L’argument target spécifie la cible à utiliser pour la vue. Seules certaines cibles peuvent être utilisées, en fonction de la cible d’origine. Par exemple, une vue sur une texture de type « Target1DArray » peut spécifier soit Target1DArray, soit Target1D; mais pour cette dernière, le nombre de couches de tableau spécifié par minimumLayer et maximumLayer doit être exactement égal à 1.

Des contraintes similaires s’appliquent à l’ viewFormat. Consultez le lien ci-dessus et la spécification pour plus de détails.

Les arguments minimumMipmapLevel, maximumMipmapLevel, minimumLayer et maximumLayer servent à restreindre les parties de la texture accessibles par la vue de texture.

Si la création de la vue de texture échoue, cette fonction renvoie 0. Si la fonction aboutit, elle renvoie un pointeur vers un nouvel objet QOpenGLTexture qui renverra true à partir de sa fonction isTextureView().

Voir également isTextureView().

int QOpenGLTexture::depth() const

Renvoie la profondeur d'une texture 3D.

Voir également width(), height() et setSize().

QOpenGLTexture::DepthStencilMode QOpenGLTexture::depthStencilMode() const

Renvoie le mode stencil de profondeur pour les textures utilisant un format combiné profondeur/stencil.

Voir également setDepthStencilMode().

void QOpenGLTexture::destroy()

Détruit l'objet de texture OpenGL sous-jacent. Cette fonction nécessite un contexte OpenGL valide et actif.

Voir également create(), isCreated() et textureId().

int QOpenGLTexture::faces() const

Renvoie le nombre de faces de cette texture. Pour les cibles de type « cubemap » et « cubemap array », cette valeur sera égale à 6.

Pour les cibles de type autre que « cubemap », cette fonction renvoie 1.

QOpenGLTexture::TextureFormat QOpenGLTexture::format() const

Renvoie le format de cet objet de texture.

Voir aussi setFormat().

void QOpenGLTexture::generateMipMaps()

Génère des mipmaps pour cet objet de texture à partir du niveau de mipmap 0. Si vous utilisez une cible de texture et une option de filtrage nécessitant des mipmaps et que vous avez désactivé la génération automatique de mipmaps, vous devez alors appeler cette fonction ou sa surcharge pour créer la chaîne de mipmaps.

Voir également setAutoMipMapGenerationEnabled(), setMipLevels() et mipLevels().

void QOpenGLTexture::generateMipMaps(int baseLevel, bool resetBaseLevel = true)

Génère des mipmaps pour cet objet de texture à partir du niveau de mipmap baseLevel. Si vous utilisez une cible de texture et une option de filtrage nécessitant des mipmaps et que vous avez désactivé la génération automatique de mipmaps, vous devez alors appeler cette fonction ou sa surcharge pour créer la chaîne de mipmaps.

La génération de mipmaps au-delà de baseLevel s’effectue en définissant le niveau de base des mipmaps sur baseLevel, puis en générant la chaîne de mipmaps. Si resetBaseLevel vaut true, le niveau de base (baseLevel) de la texture sera réinitialisé à sa valeur précédente.

Voir également setAutoMipMapGenerationEnabled(), setMipLevels() et mipLevels().

[static] bool QOpenGLTexture::hasFeature(QOpenGLTexture::Feature feature)

Renvoie « true » si votre implémentation OpenGL et sa version prennent en charge la fonctionnalité de texture « feature ».

int QOpenGLTexture::height() const

Renvoie la hauteur d'une texture 2D ou 3D.

Voir également width(), depth() et setSize().

bool QOpenGLTexture::isAutoMipMapGenerationEnabled() const

Indique si la génération automatique de mipmaps est activée pour cet objet de texture.

Voir également setAutoMipMapGenerationEnabled() et generateMipMaps().

bool QOpenGLTexture::isBound() const

Renvoie ` true ` si cette texture est associée à la cible correspondante de l'unité de texture actuellement active.

Voir également bind() et release().

bool QOpenGLTexture::isBound(uint unit)

Renvoie ` true ` si cette texture est associée à la cible correspondante de l'unité de texture ` unit`.

Voir également bind() et release().

bool QOpenGLTexture::isCreated() const

Renvoie « true » si l'objet de texture OpenGL sous-jacent a été créé.

Voir également create(), destroy() et textureId().

bool QOpenGLTexture::isFixedSamplePositions() const

Indique si cette texture utilise un schéma fixe d'échantillons multisample. Si aucun espace mémoire n'a encore été alloué à cette texture, cette fonction renvoie le paramètre de position d'échantillon fixe demandé.

Pour les cibles de texture qui ne prennent pas en charge le multisampling, cette fonction renvoie ` true`.

Voir également setFixedSamplePositions() et isStorageAllocated().

bool QOpenGLTexture::isStorageAllocated() const

Renvoie « true » si l'espace de stockage côté serveur pour cette texture a été alloué.

Le format de la texture, ses dimensions, les niveaux de mipmap et les couches du tableau ne peuvent plus être modifiés une fois l'espace de stockage alloué.

Voir également allocateStorage(), setSize(), setMipLevels(), setLayers() et setFormat().

bool QOpenGLTexture::isTextureView() const

Renvoie ` true ` si cet objet de texture est en réalité une vue sur un autre objet de texture.

Voir aussi createTextureView().

int QOpenGLTexture::layers() const

Renvoie le nombre de couches de tableau pour cette texture. Si aucun espace de stockage n'a encore été alloué à cette texture, cette fonction renvoie le nombre de couches de tableau demandé.

Pour les cibles de texture qui ne prennent pas en charge les couches de tableau, cette fonction renvoie 1.

Voir également setLayers() et isStorageAllocated().

std::pair<float, float> QOpenGLTexture::levelOfDetailRange() const

Renvoie les valeurs minimale et maximale des paramètres de niveau de détail.

Voir également setLevelOfDetailRange(), minimumLevelOfDetail() et maximumLevelOfDetail().

float QOpenGLTexture::levelofDetailBias() const

Renvoie le paramètre de biais du niveau de détail.

Voir également setLevelofDetailBias().

QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const

Renvoie le filtre de grossissement.

Voir aussi setMagnificationFilter().

float QOpenGLTexture::maximumAnisotropy() const

Renvoie le niveau maximal d'anisotropie à prendre en compte lors des recherches de textures. Cette fonction nécessite l'extension GL_EXT_texture_filter_anisotropic.

Voir également setMaximumAnisotropy().

float QOpenGLTexture::maximumLevelOfDetail() const

Renvoie le paramètre de niveau de détail maximal.

Voir également setMaximumLevelOfDetail(), minimumLevelOfDetail() et levelOfDetailRange().

int QOpenGLTexture::maximumMipLevels() const

Renvoie le nombre maximal de niveaux de mipmap que cette texture peut comporter, compte tenu de ses dimensions actuelles.

Voir également setMipLevels(), mipLevels() et setSize().

std::pair<QOpenGLTexture::Filter, QOpenGLTexture::Filter> QOpenGLTexture::minMagFilters() const

Renvoie les filtres de réduction et d'agrandissement actuels.

Voir aussi setMinMagFilters().

QOpenGLTexture::Filter QOpenGLTexture::minificationFilter() const

Renvoie le filtre de minification.

Voir aussi setMinificationFilter().

float QOpenGLTexture::minimumLevelOfDetail() const

Renvoie le paramètre de niveau de détail minimal.

Voir également setMinimumLevelOfDetail(), maximumLevelOfDetail() et levelOfDetailRange().

int QOpenGLTexture::mipBaseLevel() const

Renvoie le niveau de base du mipmap utilisé pour toutes les consultations de cette texture. La valeur par défaut est 0.

Voir également setMipBaseLevel(), mipMaxLevel() et mipLevelRange().

std::pair<int, int> QOpenGLTexture::mipLevelRange() const

Renvoie la plage des niveaux de mipmap pouvant être utilisés pour les recherches de texture avec cette texture.

Voir également setMipLevelRange(), mipBaseLevel() et mipMaxLevel().

int QOpenGLTexture::mipLevels() const

Renvoie le nombre de niveaux de mipmap pour cette texture. Si aucun espace mémoire n'a encore été alloué à cette texture, cette fonction renvoie le nombre de niveaux de mipmap demandé.

Voir également setMipLevels(), maximumMipLevels() et isStorageAllocated().

int QOpenGLTexture::mipMaxLevel() const

Renvoie le niveau maximal de mipmap utilisé pour toutes les consultations de cette texture.

Voir également setMipMaxLevel(), mipBaseLevel() et mipLevelRange().

void QOpenGLTexture::release()

Désassocie cette texture de l'unité de texture actuellement active.

Voir également bind().

void QOpenGLTexture::release(uint unit, QOpenGLTexture::TextureUnitReset reset = DontResetTextureUnit)

Désassocie cette texture de l'unité de texture unit.

Si le paramètre reset vaut true, cette fonction rétablit l'unité active à l'unité de texture qui était active au moment de l'appel.

int QOpenGLTexture::samples() const

Renvoie le nombre de points d'échantillonnage multi-échantillonnés pour cette texture. Si aucun espace mémoire n'a encore été alloué à cette texture, cette fonction renvoie le nombre d'échantillons demandé.

Pour les cibles de texture qui ne prennent pas en charge le multi-échantillonnage, cette fonction renvoie 0.

Voir également setSamples() et isStorageAllocated().

void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)

Si la propriété ` enabled ` est définie sur ` true`, la génération automatique de mipmaps pour cet objet de texture est activée dès que les données de mipmap de niveau 0 sont définies via la fonction ` setData()`.

La génération automatique de mipmaps est activée par défaut.

Voir également isAutoMipMapGenerationEnabled() et generateMipMaps().

void QOpenGLTexture::setBorderColor(const QColor &color)

Définit la couleur de la bordure de la texture sur color.

Voir également ` borderColor()`.

void QOpenGLTexture::setBorderColor(float r, float g, float b, float a)

Définit la couleur rouge sur r, la verte sur g, la bleue sur b et la valeur alpha sur a.

void QOpenGLTexture::setBorderColor(int r, int g, int b, int a)

Définit la couleur rouge sur r, la couleur verte sur g, la couleur bleue sur b et la valeur alpha sur a.

void QOpenGLTexture::setBorderColor(uint r, uint g, uint b, uint a)

Définit la couleur rouge sur r, la couleur verte sur g, la couleur bleue sur b et la valeur alpha sur a.

void QOpenGLTexture::setComparisonFunction(QOpenGLTexture::ComparisonFunction function)

Définit la fonction de comparaison de texture de cette texture sur « function ». La fonction de comparaison de texture est utilisée par les échantillonneurs d'ombres lors de l'échantillonnage d'une texture de profondeur.

Voir également comparisonFunction().

void QOpenGLTexture::setComparisonMode(QOpenGLTexture::ComparisonMode mode)

Définit le mode de comparaison de cette texture sur « mode ». Le mode de comparaison de texture est utilisé par les échantillonneurs d'ombres lors de l'échantillonnage d'une texture de profondeur.

Voir également ` comparisonMode()`.

void QOpenGLTexture::setCompressedData(int mipLevel, int layer, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Envoie les données compressées de type « pixel » data vers mipLevel, les tableaux layer et cubeFace. Le transfert de pixels peut éventuellement être contrôlé à l'aide de options. L'argument dataSize doit spécifier la taille des données pointées par data.

Si vous n'utilisez pas une fonction compressée format(), vous devez utiliser setData() à la place de cette fonction.

void QOpenGLTexture::setCompressedData(int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setCompressedData(int mipLevel, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Le paramètre ` layerCount ` correspond au nombre de couches d'un tableau de textures qui sont chargées/remplies par cet appel.

void QOpenGLTexture::setData(int mipLevel, int layer, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Enregistre l’ data s de pixels pour cet objet de texture mipLevel, le tableau layer et cubeFace. L’espace de stockage doit avoir été alloué avant l’enregistrement des données de pixels. Certaines surcharges de la fonction setData() définissent les dimensions, les niveaux de mipmap et les couches du tableau appropriés, puis allouent l’espace de stockage à votre place si elles disposent de suffisamment d’informations pour le faire. Cela sera indiqué dans la documentation de la fonction.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut éventuellement être contrôlé par ` options`.

Si vous utilisez une fonction format() compressée, vous devez utiliser setCompressedData() à la place de cette fonction.

Voir également setCompressedData().

void QOpenGLTexture::setData(const QImage &image, QOpenGLTexture::MipMapGeneration genMipMaps = GenerateMipMaps)

Cette surcharge de la méthode `setData()` allouera automatiquement de l'espace de stockage pour vous. Les données de pixels sont contenues dans ` image`. Les mipmaps sont générées par défaut. Définissez ` genMipMaps ` sur ` DontGenerateMipMaps ` pour désactiver la génération de mipmaps.

void QOpenGLTexture::setData(QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setData(int mipLevel, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setData(int mipLevel, int layer, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

void QOpenGLTexture::setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Le paramètre ` layerCount ` correspond au nombre de couches d'un tableau de textures qui sont chargées/remplies par cet appel.

void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge sert à mettre à jour une partie de la texture. Les paramètres xOffset, yOffset et zOffset spécifient les décalages des texels au sein de la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut éventuellement être contrôlé par ` options`.

void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth, int mipLevel, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge sert à mettre à jour une partie de la texture. Les paramètres xOffset, yOffset et zOffset spécifient les décalages des texels au sein de la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de mipmap de la sous-image que l'on souhaite mettre à jour est spécifié par mipLevel.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut, de manière facultative, être contrôlé par ` options`.

void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth, int mipLevel, int layer, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge sert à mettre à jour une partie de la texture. Les paramètres xOffset, yOffset et zOffset spécifient les décalages de texels au sein de la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de mipmap et la couche de la sous-image que l'on souhaite mettre à jour sont spécifiés par mipLevel et layer.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut, de manière facultative, être contrôlé par ` options`.

void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth, int mipLevel, int layer, QOpenGLTexture::CubeMapFace face, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge sert à mettre à jour une partie de la texture. Les paramètres xOffset, yOffset et zOffset spécifient les décalages de texels au sein de la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de mipmap, la couche et la face de la carte cubique de la sous-image que l'on souhaite mettre à jour sont spécifiés par mipLevel, layer et face.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut être contrôlé de manière facultative par ` options`.

void QOpenGLTexture::setData(int xOffset, int yOffset, int zOffset, int width, int height, int depth, int mipLevel, int layer, QOpenGLTexture::CubeMapFace face, int layerCount, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge sert à mettre à jour une partie de la texture. Les paramètres xOffset, yOffset et zOffset spécifient les décalages des texels au sein de la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de la mipmap, la couche de départ, la face de la carte cubique et le nombre de couches de la sous-image que l'on souhaite mettre à jour sont spécifiés respectivement par mipLevel, layer, face et layerCount.

La structure des données de pixels pointées par ` data ` est spécifiée par ` sourceFormat ` et ` sourceType`. Le chargement des données de pixels peut éventuellement être contrôlé par ` options`.

void QOpenGLTexture::setDepthStencilMode(QOpenGLTexture::DepthStencilMode mode)

Si vous utilisez une texture au format combiné profondeur/stencil, cette fonction définit quelle composante de la texture est accessible à l'adresse mode.

Lorsque le paramètre est défini sur ` DepthMode`, l'accès à la texture depuis le shader se fera, comme d'habitude, sur la composante de profondeur sous la forme d'un nombre à virgule flottante unique. En revanche, lorsque le paramètre est défini sur ` StencilMode`, le shader accédera à la composante de stencil.

Voir également depthStencilMode().

void QOpenGLTexture::setFixedSamplePositions(bool fixed)

Définit si les positions d'échantillonnage et le nombre d'échantillons utilisés avec une cible de texture prenant en charge le multi-échantillonnage doivent être « fixed ». Si la valeur est définie sur « true », les positions d'échantillonnage et le nombre d'échantillons utilisés sont identiques pour tous les texels de l'image et ne dépendent ni de la taille de l'image ni du format interne. Cette fonction doit être appelée avant l'allocation de mémoire pour la texture.

Pour les cibles ne prenant pas en charge le multi-échantillonnage, cette fonction n’a aucun effet.

La valeur par défaut est true.

Voir également isFixedSamplePositions() et isStorageAllocated().

void QOpenGLTexture::setFormat(QOpenGLTexture::TextureFormat format)

Définit le format de cet objet texture sur « format ». Cette fonction doit être appelée avant l'allocation de l'espace de stockage de la texture.

Notez que tous les formats ne sont pas nécessairement pris en charge. L'ensemble exact des formats pris en charge dépend de votre implémentation et de la version d'OpenGL.

Voir également format() et allocateStorage().

void QOpenGLTexture::setLayers(int layers)

Définit le nombre d'layers s de tableau pour lesquelles de l'espace de stockage doit être alloué. Cette fonction doit être appelée avant l'allocation de l'espace de stockage pour la texture.

Pour les cibles qui ne prennent pas en charge les couches de tableau, cette fonction n'a aucun effet.

Voir également ` layers()` et ` isStorageAllocated()`.

void QOpenGLTexture::setLevelOfDetailRange(float min, float max)

Définit le niveau de détail minimum sur min et le niveau maximal sur max.

Voir également levelOfDetailRange(), setMinimumLevelOfDetail() et setMaximumLevelOfDetail().

void QOpenGLTexture::setLevelofDetailBias(float bias)

Définit le biais du niveau de détail sur « bias ». Le biais du niveau de détail influe sur le point à partir duquel les niveaux de mipmapping changent. L'augmentation de la valeur du biais du niveau de détail rend l'image globale plus floue ou plus lisse. La diminution de cette valeur rend l'image globale plus nette.

Voir également levelofDetailBias().

void QOpenGLTexture::setMagnificationFilter(QOpenGLTexture::Filter filter)

Définit le filtre de grossissement sur filter.

Voir également magnificationFilter(), setMinificationFilter() et setMinMagFilters().

void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)

Si votre implémentation d'OpenGL prend en charge l'extension GL_EXT_texture_filter_anisotropic, cette fonction définit le niveau d'anisotropie maximal à anisotropy.

Voir également maximumAnisotropy().

void QOpenGLTexture::setMaximumLevelOfDetail(float value)

Définit le niveau maximal de détail sur value. Cela limite la sélection à la mipmap de résolution la plus faible (niveau de mipmap le plus élevé). La valeur par défaut est 1000.

Voir également maximumLevelOfDetail(), setMinimumLevelOfDetail() et setLevelOfDetailRange().

void QOpenGLTexture::setMinMagFilters(QOpenGLTexture::Filter minificationFilter, QOpenGLTexture::Filter magnificationFilter)

Définit le filtre de minification sur minificationFilter et le filtre de magnification sur magnificationFilter.

Voir également minMagFilters(), setMinificationFilter() et setMagnificationFilter().

void QOpenGLTexture::setMinificationFilter(QOpenGLTexture::Filter filter)

Définit le filtre utilisé pour la minification sur filter.

Voir également minificationFilter(), setMagnificationFilter() et setMinMagFilters().

void QOpenGLTexture::setMinimumLevelOfDetail(float value)

Définit le niveau de détail minimum à value. Cela limite la sélection de la mipmap à la résolution la plus élevée (niveau de mipmap le plus bas). La valeur par défaut est -1000.

Voir également minimumLevelOfDetail(), setMaximumLevelOfDetail() et setLevelOfDetailRange().

void QOpenGLTexture::setMipBaseLevel(int baseLevel)

Définit le niveau de mipmap de base utilisé pour toutes les consultations de texture avec cette texture sur baseLevel.

Voir également mipBaseLevel(), setMipMaxLevel() et setMipLevelRange().

void QOpenGLTexture::setMipLevelRange(int baseLevel, int maxLevel)

Définit la plage des niveaux de mipmap pouvant être utilisés pour les recherches de texture avec cette texture, de baseLevel à maxLevel.

Voir également setMipBaseLevel(), setMipMaxLevel() et mipLevelRange().

void QOpenGLTexture::setMipLevels(int levels)

Pour les cibles de texture prenant en charge les mipmaps, cette fonction définit le nombre demandé d'levels de mipmap pour lesquelles il faut allouer de l'espace de stockage. Cette fonction doit être appelée avant l'allocation de l'espace de stockage pour la texture.

Si la cible de texture ne prend pas en charge les mipmaps, cette fonction n'a aucun effet.

Voir également mipLevels(), maximumMipLevels() et isStorageAllocated().

void QOpenGLTexture::setMipMaxLevel(int maxLevel)

Définit le niveau maximal de mipmap utilisé pour toutes les consultations de texture avec cette texture à maxLevel.

Voir également mipMaxLevel(), setMipBaseLevel() et setMipLevelRange().

void QOpenGLTexture::setSamples(int samples)

Définit le nombre d'échantillons ( samples ) pour lesquels il faut allouer de l'espace mémoire lors du rendu vers une cible de texture prenant en charge le multisampling. Cette fonction doit être appelée avant l'allocation de l'espace mémoire pour la texture.

Pour les cibles ne prenant pas en charge le multisampling, cette fonction n’a aucun effet.

Voir également ` samples()` et ` isStorageAllocated()`.

void QOpenGLTexture::setSize(int width, int height = 1, int depth = 1)

Définit les dimensions de cet objet de texture sur width, height et depth. La valeur par défaut pour chaque dimension est 1. La taille maximale autorisée pour une texture dépend de votre implémentation d’OpenGL. L’allocation de mémoire pour une texture dont la taille est inférieure à la taille maximale peut tout de même échouer si votre système manque de ressources.

Si une valeur non puissance de deux est fournie pour width, height ou depth et que votre implémentation OpenGL ne prend pas en charge la répétition des textures non puissances de deux, le mode de bouclage est alors automatiquement défini sur ClampToEdge.

Voir également width(), height() et depth().

void QOpenGLTexture::setSwizzleMask(QOpenGLTexture::SwizzleComponent component, QOpenGLTexture::SwizzleValue value)

Les shaders GLSL permettent de réorganiser les composantes du vec4 renvoyé par les fonctions de texture. Il est également souhaitable de pouvoir contrôler cette réorganisation à partir du code côté CPU. Cela est rendu possible grâce aux masques de permutation (swizzle masks) depuis OpenGL 3.3.

Chaque composante de la texture peut être mappée à l'une des options SwizzleValue.

Cette fonction associe l’ component à la sortie value.

Voir aussi swizzleMask().

void QOpenGLTexture::setSwizzleMask(QOpenGLTexture::SwizzleValue r, QOpenGLTexture::SwizzleValue g, QOpenGLTexture::SwizzleValue b, QOpenGLTexture::SwizzleValue a)

Les paramètres r, g, b et a correspondent aux valeurs utilisées pour définir les couleurs rouge, vert, bleu et la valeur alpha.

void QOpenGLTexture::setWrapMode(QOpenGLTexture::WrapMode mode)

Définit le mode de répétition (ou « wrap ») pour toutes les dimensions de la texture sur « mode ».

Voir également wrapMode().

void QOpenGLTexture::setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)

Définit le mode de répétition (ou « wrap ») de la texture « dimension » direction sur mode.

QOpenGLTexture::SwizzleValue QOpenGLTexture::swizzleMask(QOpenGLTexture::SwizzleComponent component) const

Renvoie le masque de swizzle pour la texture component.

Voir aussi setSwizzleMask().

QOpenGLTexture::Target QOpenGLTexture::target() const

Renvoie la cible de liaison de cette texture.

GLuint QOpenGLTexture::textureId() const

Renvoie le nom de l'objet de texture OpenGL sous-jacent ou 0 s'il n'a pas encore été créé.

Voir également create(), destroy() et isCreated().

int QOpenGLTexture::width() const

Renvoie la largeur d'une texture 1D, 2D ou 3D.

Voir également height(), depth() et setSize().

QOpenGLTexture::WrapMode QOpenGLTexture::wrapMode(QOpenGLTexture::CoordinateDirection direction) const

Renvoie le mode d'enveloppement pour la dimension de texture direction.

Voir également setWrapMode().