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 peut 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 un contexte OpenGL valide.

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

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

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

void QOpenGLTexture::allocateStorage()

Alloue un 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 cubemap.

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

Si elle est prise en charge, QOpenGLTexture utilise un stockage de texture immuable.

Une fois que le stockage a été alloué à la texture, les données des pixels peuvent être téléchargées via l'une des surcharges setData().

Voir aussi isStorageAllocated() et setData().

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

Alloue un 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 cubemap.

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

Si elle est prise en charge, QOpenGLTexture utilise un stockage de texture immuable. Cependant, si le stockage de texture immuable n'est pas disponible, alors les valeurs spécifiées pixelFormat et pixelType seront utilisées pour allouer le stockage mutable ; notez que dans certaines implémentations d'OpenGL (notamment OpenGL ES 2), elles doivent correspondre parfaitement au format et au type transmis à tout appel ultérieur à setData().

Une fois que le stockage a été alloué à la texture, les données des pixels peuvent être téléchargées via l'une des surcharges setData().

Voir aussi 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 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 aussi release().

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

Lie cette texture à l'unité de texture unit, 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 à l'entrée.

Voir aussi release().

QColor QOpenGLTexture::borderColor() const

Renvoie la couleur de la bordure de cette texture.

Voir également 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 aussi 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'adresse textureId de la texture liée à l'adresse target de l'unité de texture actuellement active.

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

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

QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const

Renvoie l'opérateur de comparaison de texture défini pour cette texture. Par défaut, une texture possède une fonction de comparaison CompareLessEqual.

Voir également setComparisonFunction().

QOpenGLTexture::ComparisonMode QOpenGLTexture::comparisonMode() const

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

Voir également setComparisonMode().

bool QOpenGLTexture::create()

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

Une fois l'objet texture créé, vous pouvez obtenir le nom de l'objet à partir de la fonction textureId(). Cela peut être 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() en votre nom.

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 est quelque peu analogue à une vue en SQL en ce sens qu'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 qu'en cas d'utilisation d'un stockage immuable. Pour plus d'informations sur les vues de texture, voir 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 Target1DArray peut spécifier Target1DArray ou Target1D, mais pour cette dernière, le nombre de couches du tableau spécifié avec minimumLayer et maximumLayer doit être exactement égal à 1.

Des contraintes similaires s'appliquent à viewFormat. Voir 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 la texture échoue, cette fonction renvoie 0. Si la fonction réussit, elle renvoie un pointeur vers un nouvel objet QOpenGLTexture qui renvoie true à partir de sa fonction isTextureView().

Voir également isTextureView().

int QOpenGLTexture::depth() const

Renvoie la profondeur d'une texture 3D.

Voir aussi width(), height() et setSize().

QOpenGLTexture::DepthStencilMode QOpenGLTexture::depthStencilMode() const

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

Voir aussi setDepthStencilMode().

void QOpenGLTexture::destroy()

Détruit l'objet texture OpenGL sous-jacent. Cela nécessite un contexte OpenGL valide.

Voir aussi create(), isCreated(), et textureId().

int QOpenGLTexture::faces() const

Renvoie le nombre de faces pour cette texture. Pour les cibles de type cubemap et cubemap array, cette valeur sera de 6.

Pour les cibles qui ne sont pas de type cubemap, la valeur retournée est 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 qui nécessite des mipmaps et que vous avez désactivé la génération automatique de mipmaps, vous devez appeler cette fonction ou la surcharge pour créer la chaîne de mipmaps.

Voir aussi 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 qui nécessitent des mipmaps et que vous avez désactivé la génération automatique de mipmaps, vous devez appeler cette fonction ou la surcharge pour créer la chaîne de mipmaps.

La génération de mipmaps au-dessus de baseLevel s'effectue en réglant le niveau de base de la mipmap sur baseLevel, puis en générant la chaîne de mipmaps. Si resetBaseLevel est true, le niveau de base 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 version et votre implémentation OpenGL supportent la fonctionnalité de texture feature.

int QOpenGLTexture::height() const

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

Voir aussi width(), depth() et setSize().

bool QOpenGLTexture::isAutoMipMapGenerationEnabled() const

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

Voir aussi setAutoMipMapGenerationEnabled() et generateMipMaps().

bool QOpenGLTexture::isBound() const

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

Voir aussi bind() et release().

bool QOpenGLTexture::isBound(uint unit)

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

Voir aussi bind() et release().

bool QOpenGLTexture::isCreated() const

Retourne true si l'objet texture OpenGL sous-jacent a été créé.

Voir aussi create(), destroy(), et textureId().

bool QOpenGLTexture::isFixedSamplePositions() const

Indique si cette texture utilise un modèle fixe d'échantillons multiples. Si le stockage n'a pas encore été alloué pour 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 multi-échantillonnage, cette fonction renvoie true.

Voir également setFixedSamplePositions() et isStorageAllocated().

bool QOpenGLTexture::isStorageAllocated() const

Renvoie true si un espace de stockage côté serveur a été alloué pour cette texture.

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

Voir aussi allocateStorage(), setSize(), setMipLevels(), setLayers() et setFormat().

bool QOpenGLTexture::isTextureView() const

Renvoie true si cet objet de texture est en fait 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 le stockage n'a pas encore été alloué pour cette texture, cette fonction renvoie le nombre de couches de tableau demandé.

Pour les cibles de texture qui ne supportent pas les couches de tableau, cette fonction renverra 1.

Voir aussi setLayers() et isStorageAllocated().

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

Renvoie les paramètres de niveau de détail minimum et maximum.

Voir aussi setLevelOfDetailRange(), minimumLevelOfDetail() et maximumLevelOfDetail().

float QOpenGLTexture::levelofDetailBias() const

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

Voir également setLevelofDetailBias().

QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const

Renvoie le filtre d'agrandissement.

Voir aussi setMagnificationFilter().

float QOpenGLTexture::maximumAnisotropy() const

Renvoie le niveau maximal d'anisotropie à prendre en compte lors de la recherche de textures. Cela nécessite l'extension GL_EXT_texture_filter_anisotropic.

Voir aussi setMaximumAnisotropy().

float QOpenGLTexture::maximumLevelOfDetail() const

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

Voir aussi setMaximumLevelOfDetail(), minimumLevelOfDetail() et levelOfDetailRange().

int QOpenGLTexture::maximumMipLevels() const

Renvoie le nombre maximal de niveaux de mipmap que cette texture peut avoir compte tenu des dimensions actuelles.

Voir aussi setMipLevels(), mipLevels(), et setSize().

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

Renvoie les filtres de minification 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 minimum.

Voir aussi setMinimumLevelOfDetail(), maximumLevelOfDetail() et levelOfDetailRange().

int QOpenGLTexture::mipBaseLevel() const

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

Voir aussi setMipBaseLevel(), mipMaxLevel() et mipLevelRange().

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

Renvoie la plage de niveaux de mipmap qui peut être utilisée pour les recherches de texture avec cette texture.

Voir aussi setMipLevelRange(), mipBaseLevel() et mipMaxLevel().

int QOpenGLTexture::mipLevels() const

Renvoie le nombre de niveaux mipmap pour cette texture. Si le stockage n'a pas encore été alloué pour cette texture, elle renvoie le nombre de niveaux mipmap demandé.

Voir aussi setMipLevels(), maximumMipLevels() et isStorageAllocated().

int QOpenGLTexture::mipMaxLevel() const

Renvoie le niveau maximum de la mipmap utilisé pour toutes les recherches de texture avec cette texture.

Voir aussi setMipMaxLevel(), mipBaseLevel(), et mipLevelRange().

void QOpenGLTexture::release()

Détache cette texture de l'unité de texture active.

Voir aussi bind().

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

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

Si le paramètre reset est true, cette fonction ramène l'unité active à l'unité de texture qui était active à l'entrée.

int QOpenGLTexture::samples() const

Renvoie le nombre de points d'échantillonnage multi-échantillons pour cette texture. Si le stockage n'a pas encore été alloué pour cette texture, cette fonction renvoie le nombre d'échantillons demandé.

Pour les cibles de texture qui ne supportent pas le multi-échantillonnage, cette fonction renverra 0.

Voir aussi setSamples() et isStorageAllocated().

void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)

Si enabled est true, la génération automatique de la mipap pour cet objet de texture est activée chaque fois que les données de la mipap de niveau 0 sont définies à l'aide de setData().

La génération automatique de mipmap 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 à color.

Voir aussi borderColor().

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

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

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

Fixe la couleur rouge à r, la couleur verte à g, la couleur bleue à b, et la valeur alpha à a.

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

Fixe la couleur rouge à r, la couleur verte à g, la couleur bleue à b, et la valeur alpha à a.

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

Définit la fonction de comparaison de texture sur cette texture à 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 texture sur cette texture à 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)

Transfère le pixel compressé data vers mipLevel, le tableau layer, et cubeFace. Le transfert du pixel 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 un fichier compressé format(), vous devez utiliser setData() au lieu 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 est le nombre de couches d'un tableau de textures qui sont téléchargées/peuplées 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)

Charge le pixel data pour cet objet de texture mipLevel, le tableau layer, et cubeFace. L'espace de stockage doit avoir été alloué avant de télécharger les données des pixels. Certaines surcharges de setData() définissent les dimensions, les niveaux de mipmap et les couches de tableau appropriés, puis allouent l'espace de stockage pour vous 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 indiquées par data est spécifiée par sourceFormat et sourceType. Le téléchargement des données de pixels peut éventuellement être contrôlé par options.

Si vous utilisez une version compressée de format(), vous devez utiliser setCompressedData() au lieu de cette fonction.

Voir aussi setCompressedData().

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

Cette surcharge de setData() allouera de l'espace de stockage pour vous. Les données relatives aux pixels sont contenues dans image. Les cartes sont générées par défaut. Définissez genMipMaps à 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 est le nombre de couches d'un tableau de textures qui sont téléchargées/peuplées 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 est utilisée pour mettre à jour une partie de la texture. Les paramètres xOffset, yOffset, zOffset spécifient les décalages de texel dans la texture. Les paramètres width, height et depth précisent les dimensions de la sous-image.

La structure des données de pixels indiquées par data est spécifiée par sourceFormat et sourceType. Le télé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 est utilisée pour mettre à jour une partie de la texture. Les paramètres xOffset, yOffset, zOffset spécifient les décalages de texel dans la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. La carte mip au niveau de la sous-image que nous voulons mettre à jour est spécifiée par mipLevel.

La structure des données de pixels indiquée par data est spécifiée par sourceFormat et sourceType. Le télé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, int layer, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge est utilisée pour mettre à jour une partie de la texture. Les paramètres xOffset, yOffset, zOffset spécifient les décalages de texel dans la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau et la couche de la carte MIP de la sous-image à mettre à jour sont spécifiés par les paramètres mipLevel et layer.

La structure des données de pixels indiquées par data est spécifiée par sourceFormat et sourceType. Le télé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, int layer, QOpenGLTexture::CubeMapFace face, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge est utilisée pour mettre à jour une partie de la texture. Les paramètres xOffset, yOffset, zOffset spécifient les décalages de texel dans la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de la mip map, la couche et la face de la cube map de la sous-image à mettre à jour sont spécifiés par mipLevel, layer et face.

La structure des données de pixels indiquées par data est spécifiée par sourceFormat et sourceType. Le télé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, int layer, QOpenGLTexture::CubeMapFace face, int layerCount, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)

Cette surcharge est utilisée pour mettre à jour une partie de la texture. Les paramètres xOffset, yOffset, zOffset spécifient les décalages de texel dans la texture. Les paramètres width, height et depth spécifient les dimensions de la sous-image. Le niveau de la mip map, la couche de départ, la face de la cube map et le nombre de couches de la sous-image que nous voulons mettre à jour sont spécifiés par mipLevel, layer, face et layerCount.

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

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

Si vous utilisez une texture ayant un format combiné profondeur/stencil, cette fonction définit la composante de la texture à laquelle vous accédez à l'adresse mode.

Lorsque le paramètre est fixé à DepthMode, l'accès à partir du nuanceur se fera normalement sur le composant de profondeur en tant que flottant unique. Mais lorsque le paramètre est défini sur StencilMode, le shader accède à la composante stencil.

Voir aussi depthStencilMode().

void QOpenGLTexture::setFixedSamplePositions(bool fixed)

Définit si les positions des échantillons et le nombre d'échantillons utilisés avec une cible de texture capable d'échantillonner plusieurs fois sont fixés à fixed. Si la valeur est fixée à true, les positions des échantillons et le nombre d'échantillons utilisés sont les mêmes pour tous les texels de l'image et ne dépendent pas de la taille de l'image ou de son format interne. Cette fonction doit être appelée avant que l'espace de stockage ne soit alloué à la texture.

Pour les cibles qui ne supportent pas 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 à format. Cette fonction doit être appelée avant que le stockage de la texture ne soit alloué.

Notez que tous les formats peuvent ne pas être supportés. L'ensemble exact des formats supportés dépend de l'implémentation et de la version d'OpenGL.

Voir aussi format() et allocateStorage().

void QOpenGLTexture::setLayers(int layers)

Définit le nombre de tableaux layers pour lesquels un espace de stockage doit être alloué. Cette fonction doit être appelée avant que l'espace de stockage ne soit alloué à la texture.

Pour les cibles qui ne supportent pas les couches de tableaux, cette fonction n'a aucun effet.

Voir aussi layers() et isStorageAllocated().

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

Définit le niveau minimum de détail des paramètres à min et le niveau maximum à max.

Voir aussi levelOfDetailRange(), setMinimumLevelOfDetail(), et setMaximumLevelOfDetail().

void QOpenGLTexture::setLevelofDetailBias(float bias)

Définit le biais du niveau de détail à bias. Le biais de niveau de détail affecte le point auquel les niveaux de mipmapping changent. L'augmentation des valeurs du niveau de détail rend les images globales plus floues ou plus douces. La diminution des valeurs rend les images globales plus nettes.

Voir aussi levelofDetailBias().

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

Définit le filtre d'agrandissement à filter.

Voir aussi magnificationFilter(), setMinificationFilter() et setMinMagFilters().

void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)

Si votre implémentation OpenGL supporte l'extension GL_EXT_texture_filter_anisotropic, cette fonction définit le niveau maximum d'anisotropie à anisotropy.

Voir également maximumAnisotropy().

void QOpenGLTexture::setMaximumLevelOfDetail(float value)

Définit le niveau de détail maximal à value. Cela limite la sélection de la mipmap de plus faible résolution (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 à minificationFilter et le filtre d'agrandissement à magnificationFilter.

Voir aussi minMagFilters(), setMinificationFilter(), et setMagnificationFilter().

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

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

Voir aussi minificationFilter(), setMagnificationFilter(), et setMinMagFilters().

void QOpenGLTexture::setMinimumLevelOfDetail(float value)

Fixe le niveau de détail minimum à value, ce qui limite la sélection de la mipmap de plus haute résolution (niveau de mipmap le plus bas). La valeur par défaut est -1000.

Voir aussi minimumLevelOfDetail(), setMaximumLevelOfDetail(), et setLevelOfDetailRange().

void QOpenGLTexture::setMipBaseLevel(int baseLevel)

Définit le niveau de base de la mipmap utilisé pour toutes les recherches de texture avec cette texture à baseLevel.

Voir aussi mipBaseLevel(), setMipMaxLevel(), et setMipLevelRange().

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

Définit la plage des niveaux de mipmap qui peuvent être utilisés pour les recherches de texture avec cette texture entre baseLevel et maxLevel.

Voir aussi setMipBaseLevel(), setMipMaxLevel(), et mipLevelRange().

void QOpenGLTexture::setMipLevels(int levels)

Pour les cibles de texture qui prennent en charge les mipmaps, cette fonction définit le nombre requis de mipmaps levels pour lesquels un espace de stockage doit être alloué. Cette fonction doit être appelée avant que l'espace de stockage ne soit alloué à la texture.

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

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

void QOpenGLTexture::setMipMaxLevel(int maxLevel)

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

Voir aussi mipMaxLevel(), setMipBaseLevel(), et setMipLevelRange().

void QOpenGLTexture::setSamples(int samples)

Définit le nombre de samples pour lesquels un espace de stockage doit être alloué lors d'un rendu vers une cible de texture capable d'effectuer des échantillonnages multiples. Cette fonction doit être appelée avant que l'espace de stockage ne soit alloué à la texture.

Pour les cibles qui ne supportent pas le multi-échantillonnage, cette fonction n'a aucun effet.

Voir aussi samples() et isStorageAllocated().

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

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

Si une texture non puissance deux width, height ou depth est fournie et que votre implémentation OpenGL ne supporte pas la répétition de textures non puissance deux, alors le mode d'enveloppement est automatiquement fixé à ClampToEdge.

Voir aussi width(), height(), et depth().

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

Les shaders GLSL sont capables de réorganiser les composants du vec4 renvoyé par les fonctions de texture. Il est également souhaitable de pouvoir contrôler ce réordonnancement à partir d'un code côté CPU. Ceci est rendu possible par les masques swizzle depuis OpenGL 3.3.

Chaque composant de la texture peut être associé à l'une des options de SwizzleValue.

Cette fonction associe 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 sont des 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 d'enveloppement (ou de répétition) pour toutes les dimensions de la texture à mode.

Voir également wrapMode().

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

Définit le mode d'enveloppement (ou de répétition) pour la dimension de texture direction à mode.

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

Renvoie le masque d'oscillation 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 texture OpenGL sous-jacent ou 0 s'il n'a pas encore été créé.

Voir aussi create(), destroy(), et isCreated().

int QOpenGLTexture::width() const

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

Voir aussi height(), depth() et setSize().

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

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

Voir également setWrapMode().