En esta página

QOpenGLTexture Class

La clase QOpenGLTexture encapsula un objeto de textura de OpenGL. Más información...

Header: #include <QOpenGLTexture>

Tipos públicos

enum BindingTarget { BindingTarget1D, BindingTarget1DArray, BindingTarget2D, BindingTarget2DArray, BindingTarget3D, …, BindingTargetBuffer }
enum ComparisonFunction { CompareLessEqual, CompareGreaterEqual, CompareLess, CompareGreater, CompareEqual, …, CompareNever }
enum ComparisonMode { CompareRefToTexture, CompareNone }
enum CoordinateDirection { DirectionS, DirectionT, DirectionR }
enum CubeMapFace { CubeMapPositiveX, CubeMapNegativeX, CubeMapPositiveY, CubeMapNegativeY, CubeMapPositiveZ, CubeMapNegativeZ }
enum DepthStencilMode { DepthMode, StencilMode }
enum Feature { ImmutableStorage, ImmutableMultisampleStorage, TextureRectangle, TextureArrays, Texture3D, …, TextureMipMapLevel }
flags Features
enum Filter { Nearest, Linear, NearestMipMapNearest, NearestMipMapLinear, LinearMipMapNearest, LinearMipMapLinear }
enum MipMapGeneration { GenerateMipMaps, DontGenerateMipMaps }
enum PixelFormat { NoSourceFormat, Red, RG, RGB, BGR, …, LuminanceAlpha }
enum PixelType { NoPixelType, Int8, UInt8, Int16, UInt16, …, Float32_D32_UInt32_S8_X24 }
enum SwizzleComponent { SwizzleRed, SwizzleGreen, SwizzleBlue, SwizzleAlpha }
enum SwizzleValue { RedValue, GreenValue, BlueValue, AlphaValue, ZeroValue, OneValue }
enum Target { Target1D, Target1DArray, Target2D, Target2DArray, Target3D, …, TargetBuffer }
enum TextureFormat { NoFormat, R8_UNorm, RG8_UNorm, RGB8_UNorm, RGBA8_UNorm, …, LuminanceAlphaFormat }
enum TextureUnitReset { ResetTextureUnit, DontResetTextureUnit }
enum WrapMode { Repeat, MirroredRepeat, ClampToEdge, ClampToBorder }

Funciones públicas

QOpenGLTexture(QOpenGLTexture::Target target)
QOpenGLTexture(const QImage &image, QOpenGLTexture::MipMapGeneration genMipMaps = GenerateMipMaps)
void allocateStorage()
void allocateStorage(QOpenGLTexture::PixelFormat pixelFormat, QOpenGLTexture::PixelType pixelType)
void bind()
void bind(uint unit, QOpenGLTexture::TextureUnitReset reset = DontResetTextureUnit)
QColor borderColor() const
void borderColor(float *border) const
void borderColor(int *border) const
void borderColor(unsigned int *border) const
QOpenGLTexture::ComparisonFunction comparisonFunction() const
QOpenGLTexture::ComparisonMode comparisonMode() const
bool create()
QOpenGLTexture *createTextureView(QOpenGLTexture::Target target, QOpenGLTexture::TextureFormat viewFormat, int minimumMipmapLevel, int maximumMipmapLevel, int minimumLayer, int maximumLayer) const
int depth() const
QOpenGLTexture::DepthStencilMode depthStencilMode() const
void destroy()
int faces() const
QOpenGLTexture::TextureFormat format() const
void generateMipMaps()
void generateMipMaps(int baseLevel, bool resetBaseLevel = true)
int height() const
bool isAutoMipMapGenerationEnabled() const
bool isBound() const
bool isBound(uint unit)
bool isCreated() const
bool isFixedSamplePositions() const
bool isStorageAllocated() const
bool isTextureView() const
int layers() const
std::pair<float, float> levelOfDetailRange() const
float levelofDetailBias() const
QOpenGLTexture::Filter magnificationFilter() const
float maximumAnisotropy() const
float maximumLevelOfDetail() const
int maximumMipLevels() const
std::pair<QOpenGLTexture::Filter, QOpenGLTexture::Filter> minMagFilters() const
QOpenGLTexture::Filter minificationFilter() const
float minimumLevelOfDetail() const
int mipBaseLevel() const
std::pair<int, int> mipLevelRange() const
int mipLevels() const
int mipMaxLevel() const
void release()
void release(uint unit, QOpenGLTexture::TextureUnitReset reset = DontResetTextureUnit)
int samples() const
void setAutoMipMapGenerationEnabled(bool enabled)
void setBorderColor(const QColor &color)
void setBorderColor(float r, float g, float b, float a)
void setBorderColor(int r, int g, int b, int a)
void setBorderColor(uint r, uint g, uint b, uint a)
void setComparisonFunction(QOpenGLTexture::ComparisonFunction function)
void setComparisonMode(QOpenGLTexture::ComparisonMode mode)
void setCompressedData(int mipLevel, int layer, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setCompressedData(int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setCompressedData(int mipLevel, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setCompressedData(int mipLevel, int layer, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setCompressedData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, int dataSize, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setData(int mipLevel, int layer, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setData(const QImage &image, QOpenGLTexture::MipMapGeneration genMipMaps = GenerateMipMaps)
void setData(QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setData(int mipLevel, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setData(int mipLevel, int layer, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void setData(int mipLevel, int layer, int layerCount, QOpenGLTexture::CubeMapFace cubeFace, QOpenGLTexture::PixelFormat sourceFormat, QOpenGLTexture::PixelType sourceType, const void *data, const QOpenGLPixelTransferOptions *const options = nullptr)
void 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)
void 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)
void 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)
void 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)
void 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)
void setDepthStencilMode(QOpenGLTexture::DepthStencilMode mode)
void setFixedSamplePositions(bool fixed)
void setFormat(QOpenGLTexture::TextureFormat format)
void setLayers(int layers)
void setLevelOfDetailRange(float min, float max)
void setLevelofDetailBias(float bias)
void setMagnificationFilter(QOpenGLTexture::Filter filter)
void setMaximumAnisotropy(float anisotropy)
void setMaximumLevelOfDetail(float value)
void setMinMagFilters(QOpenGLTexture::Filter minificationFilter, QOpenGLTexture::Filter magnificationFilter)
void setMinificationFilter(QOpenGLTexture::Filter filter)
void setMinimumLevelOfDetail(float value)
void setMipBaseLevel(int baseLevel)
void setMipLevelRange(int baseLevel, int maxLevel)
void setMipLevels(int levels)
void setMipMaxLevel(int maxLevel)
void setSamples(int samples)
void setSize(int width, int height = 1, int depth = 1)
void setSwizzleMask(QOpenGLTexture::SwizzleComponent component, QOpenGLTexture::SwizzleValue value)
void setSwizzleMask(QOpenGLTexture::SwizzleValue r, QOpenGLTexture::SwizzleValue g, QOpenGLTexture::SwizzleValue b, QOpenGLTexture::SwizzleValue a)
void setWrapMode(QOpenGLTexture::WrapMode mode)
void setWrapMode(QOpenGLTexture::CoordinateDirection direction, QOpenGLTexture::WrapMode mode)
QOpenGLTexture::SwizzleValue swizzleMask(QOpenGLTexture::SwizzleComponent component) const
QOpenGLTexture::Target target() const
GLuint textureId() const
int width() const
QOpenGLTexture::WrapMode wrapMode(QOpenGLTexture::CoordinateDirection direction) const

Miembros públicos estáticos

GLuint boundTextureId(QOpenGLTexture::BindingTarget target)
GLuint boundTextureId(uint unit, QOpenGLTexture::BindingTarget target)
bool hasFeature(QOpenGLTexture::Feature feature)

Descripción detallada

QOpenGLTexture facilita el trabajo con texturas OpenGL y la gran variedad de características y destinos que ofrecen en función de las capacidades de tu implementación de OpenGL.

El patrón de uso típico de QOpenGLTexture es

  • Instanciar el objeto especificando el tipo de destino de la textura
  • Establecer las propiedades que afectan a los requisitos de almacenamiento, por ejemplo, el formato de almacenamiento y las dimensiones
  • Asignar el almacenamiento del lado del servidor
  • Cargar, opcionalmente, los datos de píxeles
  • De forma opcional, configurar cualquier propiedad adicional, por ejemplo, opciones de filtrado y de bordes
  • Realizar el renderizado con textura o renderizar en textura

En el caso habitual de utilizar simplemente un « QImage » como fuente de los datos de píxeles de la textura, la mayoría de los pasos anteriores se realizan automáticamente.

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

Ten en cuenta que la función « QImage » se invierte verticalmente para tener en cuenta que OpenGL y QImage utilizan direcciones opuestas para el eje y. Otra opción sería transformar las coordenadas de textura.

Advertencia: Se espera quetodos los datos utilizados por QOpenGLTexture sean de confianza. Los datos de píxeles e imágenes se transmiten a la implementación subyacente de OpenGL. Se recomienda a los desarrolladores de aplicaciones que consideren cuidadosamente las posibles implicaciones antes de pasar contenido proporcionado por el usuario a funciones como setData().

Documentación de tipos de miembros

enum QOpenGLTexture::BindingTarget

Esta enumeración define los posibles destinos de enlace de las unidades de textura.

ConstanteValorDescripción
QOpenGLTexture::BindingTarget1D0x8068Equivalente a GL_TEXTURE_BINDING_1D
QOpenGLTexture::BindingTarget1DArray0x8C1CEquivalente a GL_TEXTURE_BINDING_1D_ARRAY
QOpenGLTexture::BindingTarget2D0x8069Equivalente a GL_TEXTURE_BINDING_2D
QOpenGLTexture::BindingTarget2DArray0x8C1DEquivalente a GL_TEXTURE_BINDING_2D_ARRAY
QOpenGLTexture::BindingTarget3D0x806AEquivalente a GL_TEXTURE_BINDING_3D
QOpenGLTexture::BindingTargetCubeMap0x8514Equivalente a GL_TEXTURE_BINDING_CUBE_MAP
QOpenGLTexture::BindingTargetCubeMapArray0x900AEquivalente a GL_TEXTURE_BINDING_CUBE_MAP_ARRAY
QOpenGLTexture::BindingTarget2DMultisample0x9104Equivalente a GL_TEXTURE_BINDING_2D_MULTISAMPLE
QOpenGLTexture::BindingTarget2DMultisampleArray0x9105Equivalente a GL_TEXTURE_BINDING_2D_MULTISAMPLE_ARRAY
QOpenGLTexture::BindingTargetRectangle0x84F6Equivalente a GL_TEXTURE_BINDING_RECTANGLE
QOpenGLTexture::BindingTargetBuffer0x8C2CEquivalente a GL_TEXTURE_BINDING_BUFFER

enum QOpenGLTexture::ComparisonFunction

Esta enumeración especifica qué operador de comparación se utiliza cuando se habilita la comparación de texturas en esta textura.

ConstanteValorDescripción
QOpenGLTexture::CompareLessEqual0x0203Equivalente a GL_LEQUAL.
QOpenGLTexture::CompareGreaterEqual0x0206Equivalente a GL_GEQUAL.
QOpenGLTexture::CompareLess0x0201Equivalente a GL_LESS.
QOpenGLTexture::CompareGreater0x0204Equivalente a GL_GREATER.
QOpenGLTexture::CompareEqual0x0202Equivalente a GL_EQUAL.
QOpenGLTexture::CompareNotEqual0x0205Equivalente a GL_NOTEQUAL.
QOpenGLTexture::CompareAlways0x0207Equivalente a GL_ALWAYS.
QOpenGLTexture::CompareNever0x0200Equivalente a GL_NEVER.

enum QOpenGLTexture::ComparisonMode

Esta enumeración especifica qué modo de comparación se utiliza al muestrear esta textura.

ConstanteValorDescripción
QOpenGLTexture::CompareRefToTexture0x884EEquivalente a GL_COMPARE_REF_TO_TEXTURE.
QOpenGLTexture::CompareNone0x0000Equivalente a GL_NONE.

enum QOpenGLTexture::CoordinateDirection

Esta enumeración define las posibles direcciones de las coordenadas de textura

ConstanteValorDescripción
QOpenGLTexture::DirectionS0x2802La dirección horizontal. Equivalente a GL_TEXTURE_WRAP_S
QOpenGLTexture::DirectionT0x2803La dirección vertical. Equivalente a GL_TEXTURE_WRAP_T
QOpenGLTexture::DirectionR0x8072La dirección de profundidad. Equivalente a GL_TEXTURE_WRAP_R

enum QOpenGLTexture::CubeMapFace

Esta enumeración define las posibles caras de un CubeMap.

ConstanteValorDescripción
QOpenGLTexture::CubeMapPositiveX0x8515Equivalente a GL_TEXTURE_CUBE_MAP_POSITIVE_X
QOpenGLTexture::CubeMapNegativeX0x8516Equivalente a GL_TEXTURE_CUBE_MAP_NEGATIVE_X
QOpenGLTexture::CubeMapPositiveY0x8517Equivalente a GL_TEXTURE_CUBE_MAP_POSITIVE_Y
QOpenGLTexture::CubeMapNegativeY0x8518Equivalente a GL_TEXTURE_CUBE_MAP_NEGATIVE_Y
QOpenGLTexture::CubeMapPositiveZ0x8519Equivalente a GL_TEXTURE_CUBE_MAP_POSITIVE_Z
QOpenGLTexture::CubeMapNegativeZ0x851AEquivalente a GL_TEXTURE_CUBE_MAP_NEGATIVE_Z

enum QOpenGLTexture::DepthStencilMode

Esta enumeración especifica a qué componente de una textura de profundidad/plantilla se accede al muestrear la textura.

ConstanteValorDescripción
QOpenGLTexture::DepthMode0x1902Equivalente a GL_DEPTH_COMPONENT.
QOpenGLTexture::StencilMode0x1901Equivalente a GL_STENCIL_INDEX.

enum QOpenGLTexture::Feature
flags QOpenGLTexture::Features

Esta enumeración define las características relacionadas con las texturas de OpenGL que se pueden comprobar.

ConstanteValorDescripción
QOpenGLTexture::ImmutableStorage0x00000001Compatibilidad con el almacenamiento de texturas inmutables
QOpenGLTexture::ImmutableMultisampleStorage0x00000002Compatibilidad con el almacenamiento de texturas inmutables con destinos de muestreo múltiple
QOpenGLTexture::TextureRectangle0x00000004Compatibilidad con el destino GL_TEXTURE_RECTANGLE
QOpenGLTexture::TextureArrays0x00000008Compatibilidad con destinos de textura con capas de matriz
QOpenGLTexture::Texture3D0x00000010Compatibilidad con el destino de textura tridimensional
QOpenGLTexture::TextureMultisample0x00000020Compatibilidad con destinos de textura que admiten multimuestreo
QOpenGLTexture::TextureBuffer0x00000040Compatibilidad con texturas que utilizan objetos de búfer de OpenGL como fuente de datos
QOpenGLTexture::TextureCubeMapArrays0x00000080Compatibilidad con el destino de textura de matriz de mapa cúbico
QOpenGLTexture::Swizzle0x00000100Compatibilidad con máscaras de permutación de componentes de textura
QOpenGLTexture::StencilTexturing0x00000200Compatibilidad con texturizado de estarcido (es decir, consulta de los componentes de profundidad o estarcido de una textura con formato combinado de profundidad/estarcido en sombreadores GLSL).
QOpenGLTexture::AnisotropicFiltering0x00000400Compatibilidad con el filtrado anisotrópico de texturas
QOpenGLTexture::NPOTTextures0x00000800Compatibilidad básica con texturas que no son potencias de dos
QOpenGLTexture::NPOTTextureRepeat0x00001000Compatibilidad total con texturas que no son potencias de dos, incluidos los modos de repetición de texturas
QOpenGLTexture::Texture1D0x00002000Compatibilidad con el destino de textura unidimensional
QOpenGLTexture::TextureComparisonOperators0x00004000Compatibilidad con operadores de comparación de texturas
QOpenGLTexture::TextureMipMapLevel0x00008000Compatibilidad con la configuración de los niveles base y máximo de mipmap

El tipo «Features» es un typedef para QFlags<Feature>. Almacena una combinación OR de valores de Feature.

enum QOpenGLTexture::Filter

Esta enumeración define los parámetros de filtrado para un objeto ` QOpenGLTexture `.

ConstanteValorDescripción
QOpenGLTexture::Nearest0x2600Equivalente a GL_NEAREST
QOpenGLTexture::Linear0x2601Equivalente a GL_LINEAR
QOpenGLTexture::NearestMipMapNearest0x2700Equivalente a GL_NEAREST_MIPMAP_NEAREST
QOpenGLTexture::NearestMipMapLinear0x2702Equivalente a GL_NEAREST_MIPMAP_LINEAR
QOpenGLTexture::LinearMipMapNearest0x2701Equivalente a GL_LINEAR_MIPMAP_NEAREST
QOpenGLTexture::LinearMipMapLinear0x2703Equivalente a GL_LINEAR_MIPMAP_LINEAR

enum QOpenGLTexture::MipMapGeneration

Esta enumeración define las opciones para controlar la generación de mipmaps.

ConstanteValorDescripción
QOpenGLTexture::GenerateMipMaps0Se deben generar mipmaps
QOpenGLTexture::DontGenerateMipMaps1No se deben generar mipmaps

enum QOpenGLTexture::PixelFormat

Esta enumeración define los posibles formatos de píxeles del lado del cliente para una operación de transferencia de píxeles.

ConstanteValorDescripción
QOpenGLTexture::NoSourceFormat0Equivalente a GL_NONE
QOpenGLTexture::Red0x1903Equivalente a GL_RED
QOpenGLTexture::RG0x8227Equivalente a GL_RG
QOpenGLTexture::RGB0x1907Equivalente a GL_RGB
QOpenGLTexture::BGR0x80E0Equivalente a GL_BGR
QOpenGLTexture::RGBA0x1908Equivalente a GL_RGBA
QOpenGLTexture::BGRA0x80E1Equivalente a GL_BGRA
QOpenGLTexture::Red_Integer0x8D94Equivalente a GL_RED_INTEGER
QOpenGLTexture::RG_Integer0x8228Equivalente a GL_RG_INTEGER
QOpenGLTexture::RGB_Integer0x8D98Equivalente a GL_RGB_INTEGER
QOpenGLTexture::BGR_Integer0x8D9AEquivalente a GL_BGR_INTEGER
QOpenGLTexture::RGBA_Integer0x8D99Equivalente a GL_RGBA_INTEGER
QOpenGLTexture::BGRA_Integer0x8D9BEquivalente a GL_BGRA_INTEGER
QOpenGLTexture::Stencil0x1901Equivalente a GL_STENCIL_INDEX. Introducido en Qt 5.4
QOpenGLTexture::Depth0x1902Equivalente a GL_DEPTH_COMPONENT
QOpenGLTexture::DepthStencil0x84F9Equivalente a GL_DEPTH_STENCIL
QOpenGLTexture::Alpha0x1906Equivalente a GL_ALPHA (solo OpenGL ES 2)
QOpenGLTexture::Luminance0x1909Equivalente a GL_LUMINANCE (solo OpenGL ES 2)
QOpenGLTexture::LuminanceAlpha0x190AEquivalente a GL_LUMINANCE_ALPHA (solo OpenGL ES 2)

enum QOpenGLTexture::PixelType

Esta enumeración define los posibles tipos de datos de píxel para una operación de transferencia de píxeles

ConstanteValorDescripción
QOpenGLTexture::NoPixelType0Equivalente a GL_NONE
QOpenGLTexture::Int80x1400Equivalente a GL_BYTE
QOpenGLTexture::UInt80x1401Equivalente a GL_UNSIGNED_BYTE
QOpenGLTexture::Int160x1402Equivalente a GL_SHORT
QOpenGLTexture::UInt160x1403Equivalente a GL_UNSIGNED_SHORT
QOpenGLTexture::Int320x1404Equivalente a GL_INT
QOpenGLTexture::UInt320x1405Equivalente a GL_UNSIGNED_INT
QOpenGLTexture::Float160x140BEquivalente a GL_HALF_FLOAT
QOpenGLTexture::Float16OES0x8D61Equivalente a GL_HALF_FLOAT_OES
QOpenGLTexture::Float320x1406Equivalente a GL_FLOAT
QOpenGLTexture::UInt32_RGB9_E50x8C3EEquivalente a GL_UNSIGNED_INT_5_9_9_9_REV
QOpenGLTexture::UInt32_RG11B10F0x8C3BEquivalente a GL_UNSIGNED_INT_10F_11F_11F_REV
QOpenGLTexture::UInt8_RG3B20x8032Equivalente a GL_UNSIGNED_BYTE_3_3_2
QOpenGLTexture::UInt8_RG3B2_Rev0x8362Equivalente a GL_UNSIGNED_BYTE_2_3_3_REV
QOpenGLTexture::UInt16_RGB5A10x8034Equivalente a GL_UNSIGNED_SHORT_5_5_5_1
QOpenGLTexture::UInt16_RGB5A1_Rev0x8366Equivalente a GL_UNSIGNED_SHORT_1_5_5_5_REV
QOpenGLTexture::UInt16_R5G6B50x8363Equivalente a GL_UNSIGNED_SHORT_5_6_5
QOpenGLTexture::UInt16_R5G6B5_Rev0x8364Equivalente a GL_UNSIGNED_SHORT_5_6_5_REV
QOpenGLTexture::UInt16_RGBA40x8033Equivalente a GL_UNSIGNED_SHORT_4_4_4_4
QOpenGLTexture::UInt16_RGBA4_Rev0x8365Equivalente a GL_UNSIGNED_SHORT_4_4_4_4_REV
QOpenGLTexture::UInt32_RGBA80x8035Equivalente a GL_UNSIGNED_INT_8_8_8_8
QOpenGLTexture::UInt32_RGBA8_Rev0x8367Equivalente a GL_UNSIGNED_INT_8_8_8_8_REV
QOpenGLTexture::UInt32_RGB10A20x8036Equivalente a GL_UNSIGNED_INT_10_10_10_2
QOpenGLTexture::UInt32_RGB10A2_Rev0x8368Equivalente a GL_UNSIGNED_INT_2_10_10_10_REV
QOpenGLTexture::UInt32_D24S80x84FAEquivalente a GL_UNSIGNED_INT_24_8. Introducido en Qt 5.4
QOpenGLTexture::Float32_D32_UInt32_S8_X240x8DADEquivalente a GL_FLOAT_32_UNSIGNED_INT_24_8_REV. Introducido en Qt 5.4

enum QOpenGLTexture::SwizzleComponent

Esta enumeración define los componentes de color de la textura a los que se les puede asignar una máscara de swizzle.

ConstanteValorDescripción
QOpenGLTexture::SwizzleRed0x8E42El componente rojo. Equivalente a GL_TEXTURE_SWIZZLE_R
QOpenGLTexture::SwizzleGreen0x8E43El componente verde. Equivalente a GL_TEXTURE_SWIZZLE_G
QOpenGLTexture::SwizzleBlue0x8E44El componente azul. Equivalente a GL_TEXTURE_SWIZZLE_B
QOpenGLTexture::SwizzleAlpha0x8E45El componente alfa. Equivalente a GL_TEXTURE_SWIZZLE_A

enum QOpenGLTexture::SwizzleValue

Esta enumeración define los posibles valores de máscara para el «texture swizzling».

ConstanteValorDescripción
QOpenGLTexture::RedValue0x1903Asigna el componente al canal rojo. Equivalente a GL_RED
QOpenGLTexture::GreenValue0x1904Asigna el componente al canal verde. Equivalente a GL_GREEN
QOpenGLTexture::BlueValue0x1905Asigna el componente al canal azul. Equivalente a GL_BLUE
QOpenGLTexture::AlphaValue0x1906Asigna el componente al canal alfa. Equivalente a GL_ALPHA
QOpenGLTexture::ZeroValue0Asigna el componente a un valor fijo de 0. Equivalente a GL_ZERO
QOpenGLTexture::OneValue1Asigna el componente a un valor fijo de 1. Equivalente a GL_ONE

enum QOpenGLTexture::Target

Esta enumeración define el destino de la textura de un objeto « QOpenGLTexture ». Para obtener más información sobre cómo crear texturas de matriz, consulta «Textura de matriz».

ConstanteValorDescripción
QOpenGLTexture::Target1D0x0DE0Una textura unidimensional. Equivalente a GL_TEXTURE_1D.
QOpenGLTexture::Target1DArray0x8C18Una matriz de texturas unidimensionales. Equivalente a GL_TEXTURE_1D_ARRAY
QOpenGLTexture::Target2D0x0DE1Una textura bidimensional. Equivalente a GL_TEXTURE_2D
QOpenGLTexture::Target2DArray0x8C1AUna matriz de texturas bidimensionales. Equivalente a GL_TEXTURE_2D_ARRAY
QOpenGLTexture::Target3D0x806FUna textura tridimensional. Equivalente a GL_TEXTURE_3D
QOpenGLTexture::TargetCubeMap0x8513Una textura de mapa cúbico. Equivalente a GL_TEXTURE_CUBE_MAP
QOpenGLTexture::TargetCubeMapArray0x9009Una matriz de texturas de mapa cúbico. Equivalente a GL_TEXTURE_CUBE_MAP_ARRAY
QOpenGLTexture::Target2DMultisample0x9100Una textura bidimensional con soporte para multimuestreo. Equivalente a GL_TEXTURE_2D_MULTISAMPLE
QOpenGLTexture::Target2DMultisampleArray0x9102Una matriz de texturas bidimensionales con soporte para multimuestreo. Equivalente a GL_TEXTURE_2D_MULTISAMPLE_ARRAY
QOpenGLTexture::TargetRectangle0x84F5Una textura bidimensional rectangular. Equivalente a GL_TEXTURE_RECTANGLE
QOpenGLTexture::TargetBuffer0x8C2AUna textura con datos procedentes de un objeto de búfer de OpenGL. Equivalente a GL_TEXTURE_BUFFER

enum QOpenGLTexture::TextureFormat

Esta enumeración define los posibles formatos de textura. Dependiendo de tu implementación de OpenGL, es posible que solo sea compatible con un subconjunto de ellos.

ConstanteValorDescripción
QOpenGLTexture::NoFormat0Equivalente a GL_NONE
QOpenGLTexture::R8_UNorm0x8229Equivalente a GL_R8
QOpenGLTexture::RG8_UNorm0x822BEquivalente a GL_RG8
QOpenGLTexture::RGB8_UNorm0x8051Equivalente a GL_RGB8
QOpenGLTexture::RGBA8_UNorm0x8058Equivalente a GL_RGBA8
QOpenGLTexture::R16_UNorm0x822AEquivalente a GL_R16
QOpenGLTexture::RG16_UNorm0x822CEquivalente a GL_RG16
QOpenGLTexture::RGB16_UNorm0x8054Equivalente a GL_RGB16
QOpenGLTexture::RGBA16_UNorm0x805BEquivalente a GL_RGBA16
QOpenGLTexture::R8_SNorm0x8F94Equivalente a GL_R8_SNORM
QOpenGLTexture::RG8_SNorm0x8F95Equivalente a GL_RG8_SNORM
QOpenGLTexture::RGB8_SNorm0x8F96Equivalente a GL_RGB8_SNORM
QOpenGLTexture::RGBA8_SNorm0x8F97Equivalente a GL_RGBA8_SNORM
QOpenGLTexture::R16_SNorm0x8F98Equivalente a GL_R16_SNORM
QOpenGLTexture::RG16_SNorm0x8F99Equivalente a GL_RG16_SNORM
QOpenGLTexture::RGB16_SNorm0x8F9AEquivalente a GL_RGB16_SNORM
QOpenGLTexture::RGBA16_SNorm0x8F9BEquivalente a GL_RGBA16_SNORM
QOpenGLTexture::R8U0x8232Equivalente a GL_R8UI
QOpenGLTexture::RG8U0x8238Equivalente a GL_RG8UI
QOpenGLTexture::RGB8U0x8D7DEquivalente a GL_RGB8UI
QOpenGLTexture::RGBA8U0x8D7CEquivalente a GL_RGBA8UI
QOpenGLTexture::R16U0x8234Equivalente a GL_R16UI
QOpenGLTexture::RG16U0x823AEquivalente a GL_RG16UI
QOpenGLTexture::RGB16U0x8D77Equivalente a GL_RGB16UI
QOpenGLTexture::RGBA16U0x8D76Equivalente a GL_RGBA16UI
QOpenGLTexture::R32U0x8236Equivalente a GL_R32UI
QOpenGLTexture::RG32U0x823CEquivalente a GL_RG32UI
QOpenGLTexture::RGB32U0x8D71Equivalente a GL_RGB32UI
QOpenGLTexture::RGBA32U0x8D70Equivalente a GL_RGBA32UI
QOpenGLTexture::R8I0x8231Equivalente a GL_R8I
QOpenGLTexture::RG8I0x8237Equivalente a GL_RG8I
QOpenGLTexture::RGB8I0x8D8FEquivalente a GL_RGB8I
QOpenGLTexture::RGBA8I0x8D8EEquivalente a GL_RGBA8I
QOpenGLTexture::R16I0x8233Equivalente a GL_R16I
QOpenGLTexture::RG16I0x8239Equivalente a GL_RG16I
QOpenGLTexture::RGB16I0x8D89Equivalente a GL_RGB16I
QOpenGLTexture::RGBA16I0x8D88Equivalente a GL_RGBA16I
QOpenGLTexture::R32I0x8235Equivalente a GL_R32I
QOpenGLTexture::RG32I0x823BEquivalente a GL_RG32I
QOpenGLTexture::RGB32I0x8D83Equivalente a GL_RGB32I
QOpenGLTexture::RGBA32I0x8D82Equivalente a GL_RGBA32I
QOpenGLTexture::R16F0x822DEquivalente a GL_R16F
QOpenGLTexture::RG16F0x822FEquivalente a GL_RG16F
QOpenGLTexture::RGB16F0x881BEquivalente a GL_RGB16F
QOpenGLTexture::RGBA16F0x881AEquivalente a GL_RGBA16F
QOpenGLTexture::R32F0x822EEquivalente a GL_R32F
QOpenGLTexture::RG32F0x8230Equivalente a GL_RG32F
QOpenGLTexture::RGB32F0x8815Equivalente a GL_RGB32F
QOpenGLTexture::RGBA32F0x8814Equivalente a GL_RGBA32F
QOpenGLTexture::RGB9E50x8C3DEquivalente a GL_RGB9_E5
QOpenGLTexture::RG11B10F0x8C3AEquivalente a GL_R11F_G11F_B10F
QOpenGLTexture::RG3B20x2A10Equivalente a GL_R3_G3_B2
QOpenGLTexture::R5G6B50x8D62Equivalente a GL_RGB565
QOpenGLTexture::RGB5A10x8057Equivalente a GL_RGB5_A1
QOpenGLTexture::RGBA40x8056Equivalente a GL_RGBA4
QOpenGLTexture::RGB10A20x906FEquivalente a GL_RGB10_A2UI
QOpenGLTexture::D160x81A5Equivalente a GL_DEPTH_COMPONENT16
QOpenGLTexture::D240x81A6Equivalente a GL_DEPTH_COMPONENT24
QOpenGLTexture::D24S80x88F0Equivalente a GL_DEPTH24_STENCIL8
QOpenGLTexture::D320x81A7Equivalente a GL_DEPTH_COMPONENT32
QOpenGLTexture::D32F0x8CACEquivalente a GL_DEPTH_COMPONENT32F
QOpenGLTexture::D32FS8X240x8CADEquivalente a GL_DEPTH32F_STENCIL8
QOpenGLTexture::S80x8D48Equivalente a GL_STENCIL_INDEX8. Introducido en Qt 5.4
QOpenGLTexture::RGB_DXT10x83F0Equivalente a GL_COMPRESSED_RGB_S3TC_DXT1_EXT
QOpenGLTexture::RGBA_DXT10x83F1Equivalente a GL_COMPRESSED_RGBA_S3TC_DXT1_EXT
QOpenGLTexture::RGBA_DXT30x83F2Equivalente a GL_COMPRESSED_RGBA_S3TC_DXT3_EXT
QOpenGLTexture::RGBA_DXT50x83F3Equivalente a GL_COMPRESSED_RGBA_S3TC_DXT5_EXT
QOpenGLTexture::R_ATI1N_UNorm0x8DBBEquivalente a GL_COMPRESSED_RED_RGTC1
QOpenGLTexture::R_ATI1N_SNorm0x8DBCEquivalente a GL_COMPRESSED_SIGNED_RED_RGTC1
QOpenGLTexture::RG_ATI2N_UNorm0x8DBDEquivalente a GL_COMPRESSED_RG_RGTC2
QOpenGLTexture::RG_ATI2N_SNorm0x8DBEEquivalente a GL_COMPRESSED_SIGNED_RG_RGTC2
QOpenGLTexture::RGB_BP_UNSIGNED_FLOAT0x8E8FEquivalente a GL_COMPRESSED_RGB_BPTC_UNSIGNED_FLOAT_ARB
QOpenGLTexture::RGB_BP_SIGNED_FLOAT0x8E8EEquivalente a GL_COMPRESSED_RGB_BPTC_SIGNED_FLOAT_ARB
QOpenGLTexture::RGB_BP_UNorm0x8E8CEquivalente a GL_COMPRESSED_RGBA_BPTC_UNORM_ARB
QOpenGLTexture::R11_EAC_UNorm0x9270Equivalente a GL_COMPRESSED_R11_EAC
QOpenGLTexture::R11_EAC_SNorm0x9271Equivalente a GL_COMPRESSED_SIGNED_R11_EAC
QOpenGLTexture::RG11_EAC_UNorm0x9272Equivalente a GL_COMPRESSED_RG11_EAC
QOpenGLTexture::RG11_EAC_SNorm0x9273Equivalente a GL_COMPRESSED_SIGNED_RG11_EAC
QOpenGLTexture::RGB8_ETC20x9274Equivalente a GL_COMPRESSED_RGB8_ETC2
QOpenGLTexture::SRGB8_ETC20x9275Equivalente a GL_COMPRESSED_SRGB8_ETC2
QOpenGLTexture::RGB8_PunchThrough_Alpha1_ETC20x9276Equivalente a GL_COMPRESSED_RGB8_PUNCHTHROUGH_ALPHA1_ETC2
QOpenGLTexture::SRGB8_PunchThrough_Alpha1_ETC20x9277Equivalente a GL_COMPRESSED_SRGB8_PUNCHTHROUGH_ALPHA1_ETC2
QOpenGLTexture::RGBA8_ETC2_EAC0x9278Equivalente a GL_COMPRESSED_RGBA8_ETC2_EAC
QOpenGLTexture::SRGB8_Alpha8_ETC2_EAC0x9279Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ETC2_EAC
QOpenGLTexture::RGB8_ETC10x8D64Equivalente a GL_ETC1_RGB8_OES
QOpenGLTexture::RGBA_ASTC_4x40x93B0Equivalente a GL_COMPRESSED_RGBA_ASTC_4x4_KHR
QOpenGLTexture::RGBA_ASTC_5x40x93B1Equivalente a GL_COMPRESSED_RGBA_ASTC_5x4_KHR
QOpenGLTexture::RGBA_ASTC_5x50x93B2Equivalente a GL_COMPRESSED_RGBA_ASTC_5x5_KHR
QOpenGLTexture::RGBA_ASTC_6x50x93B3Equivalente a GL_COMPRESSED_RGBA_ASTC_6x5_KHR
QOpenGLTexture::RGBA_ASTC_6x60x93B4Equivalente a GL_COMPRESSED_RGBA_ASTC_6x6_KHR
QOpenGLTexture::RGBA_ASTC_8x50x93B5Equivalente a GL_COMPRESSED_RGBA_ASTC_8x5_KHR
QOpenGLTexture::RGBA_ASTC_8x60x93B6Equivalente a GL_COMPRESSED_RGBA_ASTC_8x6_KHR
QOpenGLTexture::RGBA_ASTC_8x80x93B7Equivalente a GL_COMPRESSED_RGBA_ASTC_8x8_KHR
QOpenGLTexture::RGBA_ASTC_10x50x93B8Equivalente a GL_COMPRESSED_RGBA_ASTC_10x5_KHR
QOpenGLTexture::RGBA_ASTC_10x60x93B9Equivalente a GL_COMPRESSED_RGBA_ASTC_10x6_KHR
QOpenGLTexture::RGBA_ASTC_10x80x93BAEquivalente a GL_COMPRESSED_RGBA_ASTC_10x8_KHR
QOpenGLTexture::RGBA_ASTC_10x100x93BBEquivalente a GL_COMPRESSED_RGBA_ASTC_10x10_KHR
QOpenGLTexture::RGBA_ASTC_12x100x93BCEquivalente a GL_COMPRESSED_RGBA_ASTC_12x10_KHR
QOpenGLTexture::RGBA_ASTC_12x120x93BDEquivalente a GL_COMPRESSED_RGBA_ASTC_12x12_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_4x40x93D0Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_4x4_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_5x40x93D1Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x4_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_5x50x93D2Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_5x5_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_6x50x93D3Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x5_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_6x60x93D4Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_6x6_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_8x50x93D5Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x5_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_8x60x93D6Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x6_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_8x80x93D7Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_8x8_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_10x50x93D8Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x5_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_10x60x93D9Equivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x6_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_10x80x93DAEquivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x8_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_10x100x93DBEquivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_10x10_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_12x100x93DCEquivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x10_KHR
QOpenGLTexture::SRGB8_Alpha8_ASTC_12x120x93DDEquivalente a GL_COMPRESSED_SRGB8_ALPHA8_ASTC_12x12_KHR
QOpenGLTexture::SRGB80x8C41Equivalente a GL_SRGB8
QOpenGLTexture::SRGB8_Alpha80x8C43Equivalente a GL_SRGB8_ALPHA8
QOpenGLTexture::SRGB_DXT10x8C4CEquivalente a GL_COMPRESSED_SRGB_S3TC_DXT1_EXT
QOpenGLTexture::SRGB_Alpha_DXT10x8C4DEquivalente a GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT1_EXT
QOpenGLTexture::SRGB_Alpha_DXT30x8C4EEquivalente a GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT3_EXT
QOpenGLTexture::SRGB_Alpha_DXT50x8C4FEquivalente a GL_COMPRESSED_SRGB_ALPHA_S3TC_DXT5_EXT
QOpenGLTexture::SRGB_BP_UNorm0x8E8DEquivalente a GL_COMPRESSED_SRGB_ALPHA_BPTC_UNORM_ARB
QOpenGLTexture::DepthFormat0x1902Equivalente a GL_DEPTH_COMPONENT (solo OpenGL ES 3 o ES 2 con OES_depth_texture)
QOpenGLTexture::AlphaFormat0x1906Equivalente a GL_ALPHA (solo OpenGL ES 2)
QOpenGLTexture::RGBFormat0x1907Equivalente a GL_RGB (solo OpenGL ES 2)
QOpenGLTexture::RGBAFormat0x1908Equivalente a GL_RGBA (solo OpenGL ES 2)
QOpenGLTexture::LuminanceFormat0x1909Equivalente a GL_LUMINANCE (solo OpenGL ES 2)
QOpenGLTexture::LuminanceAlphaFormat0x190AEquivalente a GL_LUMINANCE_ALPHA (solo OpenGL ES 2)

enum QOpenGLTexture::TextureUnitReset

Esta enumeración define las opciones para controlar la activación de la unidad de texturas.

ConstanteValorDescripción
QOpenGLTexture::ResetTextureUnit0La unidad de textura que estaba activa anteriormente se restablecerá
QOpenGLTexture::DontResetTextureUnit1La unidad de textura activa anterior no se reiniciará

enum QOpenGLTexture::WrapMode

Esta enumeración define los posibles modos de envoltura de coordenadas de textura.

ConstanteValorDescripción
QOpenGLTexture::Repeat0x2901La coordenada de textura se repite. Equivalente a GL_REPEAT
QOpenGLTexture::MirroredRepeat0x8370La coordenada de textura se refleja respecto a 0 y 1. Equivalente a GL_MIRRORED_REPEAT
QOpenGLTexture::ClampToEdge0x812FLimita las coordenadas de textura al intervalo [0,1]. Equivalente a GL_CLAMP_TO_EDGE
QOpenGLTexture::ClampToBorder0x812DIgual que ClampToEdge, pero además mezcla las muestras en 0 y 1 con un color de borde fijo. Equivalente a GL_CLAMP_TO_BORDER

Documentación de las funciones miembro

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

Crea un objeto `QOpenGLTexture` que posteriormente se puede vincular a ` target`.

Esto no crea el objeto de textura OpenGL subyacente. Por lo tanto, la creación mediante este constructor no requiere un contexto OpenGL válido y activo.

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

Crea un objeto `QOpenGLTexture` que posteriormente se puede vincular al destino de textura 2D y que contiene los datos de píxeles incluidos en ` image`. Si deseas que se genere una cadena de mipmaps, establece ` genMipMaps ` en ` true ` (este es el valor por defecto).

Esto crea el objeto de textura OpenGL subyacente. Por lo tanto, la creación mediante este constructor requiere un contexto OpenGL válido y activo.

Nota: image se convierte automáticamente a QImage::Format_RGBA8888, lo que puede afectar al rendimiento en el caso de imágenes grandes con un formato diferente.

void QOpenGLTexture::allocateStorage()

Asigna almacenamiento en el servidor para este objeto de textura teniendo en cuenta el formato, las dimensiones, los niveles de mipmap, las capas de matriz y las caras del mapa cúbico.

Una vez asignado el almacenamiento, ya no es posible modificar estas propiedades.

Si está disponible, ` QOpenGLTexture ` utiliza almacenamiento de texturas inmutable.

Una vez asignado el almacenamiento para la textura, los datos de píxeles se pueden cargar mediante una de las sobrecargas de setData().

Nota: Si el almacenamiento de texturas inmutable no está disponible, se utilizarán un formato de píxel y un tipo de píxel predeterminados para crear el almacenamiento mutable. Puedes utilizar la otra sobrecarga de `allocateStorage()` para especificar exactamente el formato de píxel y el tipo de píxel que se utilizarán al asignar almacenamiento mutable; esto resulta especialmente útil en determinadas implementaciones de OpenGL ES (en particular, OpenGL ES 2), donde el formato y el tipo de píxel utilizados en el momento de la asignación deben coincidir perfectamente con el formato y el tipo pasados a cualquier llamada posterior a setData().

Véanse también isStorageAllocated() y setData().

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

Asigna almacenamiento en el servidor para este objeto de textura teniendo en cuenta el formato, las dimensiones, los niveles de mipmap, las capas de la matriz y las caras del cubemap.

Una vez asignado el almacenamiento, ya no es posible modificar estas propiedades.

Si es compatible, ` QOpenGLTexture ` utiliza almacenamiento de texturas inmutable. Sin embargo, si el almacenamiento de texturas inmutable no está disponible, se utilizarán los parámetros ` pixelFormat ` y ` pixelType ` especificados para asignar almacenamiento mutable; ten en cuenta que, en determinadas implementaciones de OpenGL (en particular, OpenGL ES 2), deben coincidir perfectamente con el formato y el tipo pasados a cualquier llamada posterior a ` setData()`.

Una vez asignado el almacenamiento para la textura, los datos de píxeles pueden cargarse mediante una de las sobrecargas de setData().

Véanse también ` isStorageAllocated()` y ` setData()`.

void QOpenGLTexture::bind()

Asigna esta textura a la unidad de textura actualmente activa, lista para su renderizado. Ten en cuenta que no es necesario asignar objetos de tipo « QOpenGLTexture » para modificarlos, ya que la implementación utiliza la extensión EXT_direct_state_access cuando está disponible y la simula cuando no lo está.

Véase también ` release()`.

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

Asigna esta textura a la unidad de textura unit, dejándola lista para su renderizado. Ten en cuenta que no es necesario asignar objetos QOpenGLTexture para modificarlos, ya que la implementación utiliza la extensión EXT_direct_state_access cuando está disponible y la simula cuando no lo está.

Si el parámetro reset es true, esta función restablecerá la unidad activa a la unidad de textura que estaba activa al inicio de la función.

Véase también release().

QColor QOpenGLTexture::borderColor() const

Devuelve el color del borde de esta textura.

Véase también ` setBorderColor()`.

void QOpenGLTexture::borderColor(float *border) const

Escribe el color del borde de la textura en los cuatro primeros elementos de la matriz a la que apunta border.

Véase también setBorderColor().

void QOpenGLTexture::borderColor(int *border) const

Escribe el color del borde de la textura en los cuatro primeros elementos de la matriz a la que apunta ` border`.

Esta es una función sobrecargada.

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

Escribe el color del borde de la textura en los cuatro primeros elementos de la matriz a la que apunta ` border`.

Esta es una función sobrecargada.

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

Devuelve el ` textureId ` de la textura vinculada al ` target ` de la unidad de textura activa en ese momento.

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

Devuelve el ` textureId ` de la textura vinculada al ` target ` de la unidad de textura ` unit`.

QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const

Devuelve el operador de comparación de texturas establecido para esta textura. Por defecto, una textura tiene una función de comparación « CompareLessEqual ».

Véase también setComparisonFunction().

QOpenGLTexture::ComparisonMode QOpenGLTexture::comparisonMode() const

Devuelve el modo de comparación de texturas establecido para esta textura. Por defecto, una textura tiene el modo de comparación « CompareNone » (es decir, las comparaciones están desactivadas).

Véase también setComparisonMode().

bool QOpenGLTexture::create()

Crea el objeto de textura OpenGL subyacente. Para ello se requiere un contexto OpenGL válido y activo. Si el objeto de textura ya existe, esta función no realiza ninguna acción.

Una vez creado el objeto de textura, puedes obtener el nombre del objeto mediante la función ` textureId()`. Esto puede resultar útil si deseas realizar algunas llamadas OpenGL directas relacionadas con esta textura.

Normalmente no debería ser necesario llamar a esta función directamente, ya que todas las funciones que establecen propiedades del objeto de textura llaman implícitamente a `create()` en tu nombre.

Devuelve ` true ` si la creación se ha realizado con éxito; en caso contrario, devuelve ` false`.

Véanse también destroy(), isCreated() y textureId().

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

Intenta crear una vista de textura sobre esta textura. Una vista de textura es, en cierto modo, análoga a una vista en SQL, ya que presenta una visión restringida o reinterpretada de los datos originales. Las vistas de textura no asignan más almacenamiento en el lado del servidor, sino que se basan en el búfer de almacenamiento de la textura de origen.

Las vistas de textura solo están disponibles cuando se utiliza almacenamiento inmutable. Para obtener más información sobre las vistas de textura, consulta http://www.opengl.org/wiki/Texture_Storage#Texture_views.

El argumento « target » especifica el destino que se va a utilizar para la vista. Solo se pueden utilizar algunos destinos, dependiendo del destino de la textura original. Por ejemplo, una vista sobre una textura « Target1DArray » puede especificar « Target1DArray » o « Target1D », pero en este último caso el número de capas de matriz especificadas con « minimumLayer » y « maximumLayer » debe ser exactamente 1.

Se aplican restricciones similares para « viewFormat ». Consulta el enlace anterior y la especificación para obtener más detalles.

Los argumentos minimumMipmapLevel, maximumMipmapLevel, minimumLayer y maximumLayer sirven para restringir las partes de la textura a las que puede acceder la vista de textura.

Si falla la creación de la vista de textura, esta función devolverá 0. Si la función se ejecuta correctamente, devolverá un puntero a un nuevo objeto ` QOpenGLTexture ` que, a su vez, devolverá ` true ` desde su función ` isTextureView()`.

Véase también isTextureView().

int QOpenGLTexture::depth() const

Devuelve la profundidad de una textura 3D.

Véase también width(), height() y setSize().

QOpenGLTexture::DepthStencilMode QOpenGLTexture::depthStencilMode() const

Devuelve el modo de profundidad-estencil para texturas que utilizan un formato combinado de profundidad y estencil.

Véase también setDepthStencilMode().

void QOpenGLTexture::destroy()

Destruye el objeto de textura OpenGL subyacente. Para ello es necesario disponer de un contexto OpenGL válido y activo.

Véase también create(), isCreated() y textureId().

int QOpenGLTexture::faces() const

Devuelve el número de caras de esta textura. Para los destinos de tipo «cubemap» y «matriz de cubemaps», este valor será 6.

Para objetivos que no sean del tipo «cubemap», devolverá 1.

QOpenGLTexture::TextureFormat QOpenGLTexture::format() const

Devuelve el formato de este objeto de textura.

Véase también setFormat().

void QOpenGLTexture::generateMipMaps()

Genera mipmaps para este objeto de textura a partir del nivel 0 de mipmap. Si estás utilizando un destino de textura y una opción de filtrado que requieran mipmaps y has desactivado la generación automática de mipmaps, deberás llamar a esta función o a su sobrecarga para crear la cadena de mipmaps.

Nota: La generaciónde mipmaps no es compatible con texturas comprimidas en OpenGL ES.

Véase también setAutoMipMapGenerationEnabled(), setMipLevels() y mipLevels().

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

Genera mipmaps para este objeto de textura a partir del nivel de mipmap baseLevel. Si estás utilizando un destino de textura y una opción de filtrado que requiera mipmaps y has desactivado la generación automática de mipmaps, deberás llamar a esta función o a su sobrecarga para crear la cadena de mipmaps.

La generación de mipmaps por encima de baseLevel se consigue estableciendo el nivel base de mipmap en baseLevel y, a continuación, generando la cadena de mipmaps. Si resetBaseLevel es true, el nivel base (baseLevel) de la textura se restablecerá a su valor anterior.

Véase también setAutoMipMapGenerationEnabled(), setMipLevels() y mipLevels().

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

Devuelve « true » si tu implementación y versión de OpenGL admiten la característica de textura « feature ».

int QOpenGLTexture::height() const

Devuelve la altura de una textura 2D o 3D.

Véase también width(), depth() y setSize().

bool QOpenGLTexture::isAutoMipMapGenerationEnabled() const

Devuelve si la generación automática de mipmaps está habilitada para este objeto de textura.

Véase también setAutoMipMapGenerationEnabled() y generateMipMaps().

bool QOpenGLTexture::isBound() const

Devuelve ` true ` si esta textura está vinculada al destino correspondiente de la unidad de textura actualmente activa.

Véase también bind() y release().

bool QOpenGLTexture::isBound(uint unit)

Devuelve ` true ` si esta textura está vinculada al destino correspondiente de la unidad de textura ` unit`.

Véase también bind() y release().

bool QOpenGLTexture::isCreated() const

Devuelve « true » si se ha creado el objeto de textura OpenGL subyacente.

Véase también create(), destroy() y textureId().

bool QOpenGLTexture::isFixedSamplePositions() const

Devuelve si esta textura utiliza un patrón fijo de muestras de multimuestreo. Si aún no se ha asignado memoria para esta textura, esta función devuelve la configuración solicitada de la posición fija de la muestra.

En el caso de los destinos de textura que no admiten multimuestreo, esta función devolverá ` true`.

Véanse también setFixedSamplePositions() y isStorageAllocated().

bool QOpenGLTexture::isStorageAllocated() const

Devuelve « true » si se ha asignado almacenamiento en el servidor para esta textura.

El formato de la textura, las dimensiones, los niveles de mipmap y las capas de la matriz no se pueden modificar una vez que se ha asignado el almacenamiento.

Véase también allocateStorage(), setSize(), setMipLevels(), setLayers() y setFormat().

bool QOpenGLTexture::isTextureView() const

Devuelve ` true ` si este objeto de textura es, en realidad, una vista de otro objeto de textura.

Véase también createTextureView().

int QOpenGLTexture::layers() const

Devuelve el número de capas de matriz de esta textura. Si aún no se ha asignado memoria a esta textura, esta función devuelve el número solicitado de capas de matriz.

En el caso de los destinos de textura que no admiten capas de matriz, esta función devolverá 1.

Véase también setLayers() y isStorageAllocated().

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

Devuelve los parámetros de nivel de detalle mínimo y máximo.

Véase también setLevelOfDetailRange(), minimumLevelOfDetail() y maximumLevelOfDetail().

float QOpenGLTexture::levelofDetailBias() const

Devuelve el parámetro de sesgo del nivel de detalle.

Véase también setLevelofDetailBias().

QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const

Devuelve el filtro de ampliación.

Véase también setMagnificationFilter().

float QOpenGLTexture::maximumAnisotropy() const

Devuelve el nivel máximo de anisotropía que se debe tener en cuenta al realizar búsquedas de texturas. Para ello se requiere la extensión GL_EXT_texture_filter_anisotropic.

Véase también setMaximumAnisotropy().

float QOpenGLTexture::maximumLevelOfDetail() const

Devuelve el parámetro de nivel máximo de detalle.

Véase también setMaximumLevelOfDetail(), minimumLevelOfDetail() y levelOfDetailRange().

int QOpenGLTexture::maximumMipLevels() const

Devuelve el número máximo de niveles de mipmap que puede tener esta textura, dadas las dimensiones actuales.

Véase también setMipLevels(), mipLevels() y setSize().

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

Devuelve los filtros actuales de reducción y ampliación.

Véase también setMinMagFilters().

QOpenGLTexture::Filter QOpenGLTexture::minificationFilter() const

Devuelve el filtro de minificación.

Véase también setMinificationFilter().

float QOpenGLTexture::minimumLevelOfDetail() const

Devuelve el parámetro de nivel mínimo de detalle.

Véase también setMinimumLevelOfDetail(), maximumLevelOfDetail() y levelOfDetailRange().

int QOpenGLTexture::mipBaseLevel() const

Devuelve el nivel base del mipmap utilizado para todas las consultas de textura con esta textura. El valor por defecto es 0.

Véase también setMipBaseLevel(), mipMaxLevel() y mipLevelRange().

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

Devuelve el rango de niveles de mipmap que se pueden utilizar para las consultas de texturas con esta textura.

Véase también setMipLevelRange(), mipBaseLevel() y mipMaxLevel().

int QOpenGLTexture::mipLevels() const

Devuelve el número de niveles de mipmap de esta textura. Si aún no se ha asignado memoria para esta textura, devuelve el número solicitado de niveles de mipmap.

Véase también setMipLevels(), maximumMipLevels() y isStorageAllocated().

int QOpenGLTexture::mipMaxLevel() const

Devuelve el nivel máximo de mipmap utilizado para todas las consultas de textura con esta textura.

Véase también setMipMaxLevel(), mipBaseLevel() y mipLevelRange().

void QOpenGLTexture::release()

Desvincula esta textura de la unidad de textura activa en ese momento.

Véase también bind().

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

Desvincula esta textura de la unidad de textura unit.

Si el parámetro reset es true, esta función restablecerá la unidad activa a la unidad de textura que estaba activa al inicio de la función.

int QOpenGLTexture::samples() const

Devuelve el número de puntos de muestreo de multimuestreo de esta textura. Si aún no se ha asignado memoria para esta textura, esta función devuelve el número de muestras solicitado.

En el caso de los destinos de textura que no admiten multimuestreo, esta función devolverá 0.

Véase también setSamples() y isStorageAllocated().

void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)

Si enabled es true, se habilita la generación automática de mipmaps para este objeto de textura cada vez que se establezcan los datos del mipmap de nivel 0 mediante setData().

La generación automática de mipmaps está habilitada de forma predeterminada.

Nota: La generaciónde mipmaps no es compatible con texturas comprimidas en OpenGL ES 2.0.

Véase también isAutoMipMapGenerationEnabled() y generateMipMaps().

void QOpenGLTexture::setBorderColor(const QColor &color)

Establece el color del borde de la textura en color.

Nota: Esta función no tiene ningún efecto en Mac ni en Qt compilado para OpenGL ES 2.

Véase también borderColor().

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

Establece el color rojo en r, el verde en g, el azul en b y a como valor alfa.

Esta es una función sobrecargada.

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

Establece el color rojo en r, el verde en g, el azul en b y el valor alfa en a.

Esta es una función sobrecargada.

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

Establece el color rojo en r, el verde en g, el azul en b y el valor alfa en a.

Esta es una función sobrecargada.

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

Establece la función de comparación de texturas de esta textura en « function ». Los muestreadores de sombras utilizan la función de comparación de texturas al muestrear una textura de profundidad.

Véase también ` comparisonFunction()`.

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

Establece el modo de comparación de texturas de esta textura en « mode ». Los muestreadores de sombras utilizan el modo de comparación de texturas al muestrear una textura de profundidad.

Véase también ` comparisonMode()`.

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

Carga el pixel comprimido data en mipLevel, el array layer y cubeFace. La transferencia de píxeles se puede controlar opcionalmente con options. El argumento dataSize debe especificar el tamaño de los datos a los que apunta data.

Si no se utiliza un ` format()` comprimido, se debe utilizar ` setData()` en lugar de esta función.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

El parámetro « layerCount » es el número de capas de una matriz de texturas que se cargan o rellenan mediante esta llamada.

Se trata de una función sobrecargada.

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

Carga los datos de píxeles data para este objeto de textura mipLevel, la matriz layer y cubeFace. El espacio de almacenamiento debe haberse asignado antes de cargar los datos de píxeles. Algunas sobrecargas de setData() establecerán las dimensiones, los niveles de mipmap y las capas de la matriz adecuados y, a continuación, asignarán el espacio de almacenamiento por ti si disponen de información suficiente para hacerlo. Esto se indicará en la documentación de la función.

La estructura de los datos de píxeles a los que apunta ` data ` viene especificada por ` sourceFormat ` y ` sourceType`. La carga de datos de píxeles puede controlarse opcionalmente mediante ` options`.

Si se utiliza un ` format()` comprimido, se debe emplear ` setCompressedData()` en lugar de esta función.

Véase también setCompressedData().

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

Esta sobrecarga de setData() asignará memoria automáticamente. Los datos de píxeles se encuentran en image. Los mipmaps se generan de forma predeterminada. Establece genMipMaps en DontGenerateMipMaps para desactivar la generación de mipmaps.

Nota: image se convierte automáticamente a QImage::Format_RGBA8888, lo que puede afectar al rendimiento en el caso de imágenes grandes con un formato diferente.

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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

Esta es una función sobrecargada.

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)

El parámetro « layerCount » es el número de capas de una matriz de texturas que se están cargando o rellenando mediante esta llamada.

Se trata de una función sobrecargada.

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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset y zOffset especifican los desplazamientos de los texeles dentro de la textura. Los parámetros width, height y depth especifican las dimensiones de la subimagen.

La estructura de los datos de píxeles a los que apunta data viene determinada por sourceFormat y sourceType. La carga de los datos de píxeles puede controlarse opcionalmente mediante options.

Esta es una función sobrecargada.

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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset y zOffset especifican los desplazamientos de texel dentro de la textura. Los parámetros width, height y depth especifican las dimensiones de la subimagen. El nivel de mipmap de la subimagen que queremos actualizar se especifica con mipLevel.

La estructura de los datos de píxeles a los que apunta data se especifica mediante sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante options.

Esta es una función sobrecargada.

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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset y zOffset especifican los desplazamientos de texel dentro de la textura. Los parámetros width, height y depth especifican las dimensiones de la subimagen. El nivel del mapa mip y la capa de la subimagen que queremos actualizar se especifican con mipLevel y layer.

La estructura de los datos de píxeles a los que apunta data se especifica mediante sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante options.

Se trata de una función sobrecargada.

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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset y zOffset especifican los desplazamientos de los texeles dentro de la textura. Los parámetros width, height y depth especifican las dimensiones de la subimagen. El nivel del mapa mip, la capa y la cara del mapa cúbico de la subimagen que queremos actualizar se especifican con mipLevel, layer y face.

La estructura de los datos de píxeles a los que apunta data se especifica mediante sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante options.

Esta es una función sobrecargada.

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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset y zOffset especifican los desplazamientos de texel dentro de la textura. Los parámetros width, height y depth especifican las dimensiones de la subimagen. El nivel del mapa mip, la capa inicial, la cara del mapa cúbico y el número de capas de la subimagen que queremos actualizar se especifican con mipLevel, layer, face y layerCount.

La estructura de los datos de píxeles a los que apunta ` data ` se especifica mediante ` sourceFormat ` y ` sourceType`. La carga de datos de píxeles puede controlarse opcionalmente mediante ` options`.

Esta es una función sobrecargada.

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

Si se utiliza una textura con un formato combinado de profundidad/plantilla, esta función establece qué componente de la textura se accede como « mode ».

Cuando el parámetro se establece en « DepthMode », al acceder a él desde el sombreador se accederá al componente de profundidad como un único valor flotante, como es habitual. Sin embargo, cuando el parámetro se establece en « StencilMode », el sombreador accederá al componente de plantilla.

Nota: Esta función no tiene ningún efecto en Mac ni en Qt compilado para OpenGL ES 2.

Véase también depthStencilMode().

void QOpenGLTexture::setFixedSamplePositions(bool fixed)

Establece si las posiciones de muestreo y el número de muestras que se utilizan con un destino de textura compatible con multimuestreo se ajustan a « fixed ». Si se establece en « true », las posiciones de muestreo y el número de muestras utilizadas serán las mismas para todos los texeles de la imagen y no dependerán del tamaño de la imagen ni del formato interno. Esta función debe llamarse antes de asignar memoria para la textura.

En el caso de los destinos que no admiten multimuestreo, esta función no tiene ningún efecto.

El valor por defecto es true.

Véanse también isFixedSamplePositions() y isStorageAllocated().

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

Establece el formato de este objeto de textura en « format ». Esta función debe invocarse antes de asignar el espacio de almacenamiento de la textura.

Ten en cuenta que es posible que no todos los formatos sean compatibles. El conjunto exacto de formatos compatibles depende de tu implementación y versión de OpenGL.

Véanse también format() y allocateStorage().

void QOpenGLTexture::setLayers(int layers)

Establece el número de capas de matriz layers para las que se va a asignar espacio de almacenamiento. Esta función debe llamarse antes de asignar espacio de almacenamiento a la textura.

En el caso de los destinos que no admiten capas de matriz, esta función no tiene ningún efecto.

Véanse también layers() y isStorageAllocated().

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

Establece el nivel mínimo de detalle en min y el nivel máximo en max.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también levelOfDetailRange(), setMinimumLevelOfDetail() y setMaximumLevelOfDetail().

void QOpenGLTexture::setLevelofDetailBias(float bias)

Establece el sesgo del nivel de detalle en bias. El sesgo del nivel de detalle afecta al punto en el que cambian los niveles de mipmapping. Al aumentar los valores del sesgo del nivel de detalle, las imágenes en general se vuelven más borrosas o más suaves. Al disminuir los valores, las imágenes en general se vuelven más nítidas.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también levelofDetailBias().

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

Establece el filtro de ampliación en filter.

Véase también magnificationFilter(), setMinificationFilter() y setMinMagFilters().

void QOpenGLTexture::setMaximumAnisotropy(float anisotropy)

Si tu implementación de OpenGL es compatible con la extensión GL_EXT_texture_filter_anisotropic, esta función establece el nivel máximo de anisotropía en anisotropy.

Véase también maximumAnisotropy().

void QOpenGLTexture::setMaximumLevelOfDetail(float value)

Establece el nivel máximo de detalle en value. Esto limita la selección al mipmap de menor resolución (nivel de mipmap más alto). El valor por defecto es 1000.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también maximumLevelOfDetail(), setMinimumLevelOfDetail() y setLevelOfDetailRange().

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

Establece el filtro de minificación en minificationFilter y el filtro de ampliación en magnificationFilter.

Véase también minMagFilters(), setMinificationFilter() y setMagnificationFilter().

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

Establece el filtro utilizado para la minificación en filter.

Véase también minificationFilter(), setMagnificationFilter() y setMinMagFilters().

void QOpenGLTexture::setMinimumLevelOfDetail(float value)

Establece el nivel mínimo de detalle en « value ». Esto limita la selección del mipmap de mayor resolución (nivel de mipmap más bajo). El valor predeterminado es -1000.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también minimumLevelOfDetail(), setMaximumLevelOfDetail() y setLevelOfDetailRange().

void QOpenGLTexture::setMipBaseLevel(int baseLevel)

Establece el nivel base de mipmap utilizado para todas las consultas de textura con esta textura en « baseLevel ».

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véanse también mipBaseLevel(), setMipMaxLevel() y setMipLevelRange().

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

Establece el rango de niveles de mipmap que se pueden utilizar para las búsquedas de texturas con esta textura, de baseLevel a maxLevel.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también setMipBaseLevel(), setMipMaxLevel() y mipLevelRange().

void QOpenGLTexture::setMipLevels(int levels)

Para los destinos de textura que admiten mipmaps, esta función establece el número solicitado de mipmaps levels para los que se debe asignar espacio de almacenamiento. Esta función debe llamarse antes de asignar espacio de almacenamiento a la textura.

Si el destino de textura no admite mipmaps, esta función no tiene ningún efecto.

Véanse también mipLevels(), maximumMipLevels() y isStorageAllocated().

void QOpenGLTexture::setMipMaxLevel(int maxLevel)

Establece el nivel máximo de mipmap utilizado para todas las consultas de textura con esta textura en ` maxLevel`.

Nota: Esta función no tiene ningún efecto en Qt compilado para OpenGL ES 2.

Véase también mipMaxLevel(), setMipBaseLevel() y setMipLevelRange().

void QOpenGLTexture::setSamples(int samples)

Establece el número de « samples » para los que se debe asignar espacio de almacenamiento al renderizar en un destino de textura compatible con el multisampling. Esta función debe llamarse antes de asignar espacio de almacenamiento a la textura.

En el caso de los destinos que no admiten multimuestreo, esta función no tiene ningún efecto.

Véanse también samples() y isStorageAllocated().

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

Establece las dimensiones de este objeto de textura en width, height y depth. El valor por defecto de cada dimensión es 1. El tamaño máximo permitido de la textura depende de la implementación de OpenGL. La asignación de memoria para una textura de tamaño inferior al máximo puede fallar si el sistema tiene pocos recursos.

Si se proporciona un valor que no sea una potencia de dos para width, height o depth y su implementación de OpenGL no admite la repetición de texturas que no sean potencias de dos, el modo de envoltura se establece automáticamente en ClampToEdge.

Véase también width(), height() y depth().

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

Los shaders GLSL pueden reordenar los componentes del vec4 devuelto por las funciones de textura. También resulta conveniente poder controlar esta reordenación desde el código de la CPU. Esto es posible gracias a las máscaras de swizzle desde OpenGL 3.3.

Cada componente de la textura se puede asignar a una de las opciones de SwizzleValue.

Esta función asigna « component » a la salida « value ».

Nota: Esta función no tiene ningún efecto en Mac ni en Qt compilado para OpenGL ES 2.

Véase también swizzleMask().

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

Los parámetros r, g, b y a son valores que se utilizan para establecer los colores rojo, verde y azul, así como el valor alfa.

Se trata de una función sobrecargada.

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

Establece el modo de repetición (o «wrap») para todas las dimensiones de la textura en « mode ».

Véase también ` wrapMode()`.

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

Establece el modo de repetición (o «wrap») de la dimensión de textura direction en mode.

Esta es una función sobrecargada.

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

Devuelve la máscara de swizzle para la textura component.

Véase también setSwizzleMask().

QOpenGLTexture::Target QOpenGLTexture::target() const

Devuelve el destino de enlace de esta textura.

GLuint QOpenGLTexture::textureId() const

Devuelve el nombre del objeto de textura OpenGL subyacente o 0 si aún no se ha creado.

Véase también create(), destroy() y isCreated().

int QOpenGLTexture::width() const

Devuelve el ancho de una textura 1D, 2D o 3D.

Véase también height(), depth() y setSize().

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

Devuelve el modo de envoltura para la dimensión de la textura « direction ».

Véase también setWrapMode().

© 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.