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(...);

Documentación de las funciones miembro

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

Crea un objeto QOpenGLTexture que puede ser enlazado a target.

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

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

Crea un objeto QOpenGLTexture que puede ser enlazado posteriormente al objetivo de textura 2D y contiene los datos de pixel contenidos en image. Si deseas tener una cadena de mipmaps generados entonces establece genMipMaps a true (este es el valor por defecto).

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

void QOpenGLTexture::allocateStorage()

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

Una vez que el almacenamiento ha sido asignado ya no es posible cambiar estas propiedades.

Si es compatible, QOpenGLTexture utiliza un almacenamiento de texturas inmutable.

Una vez que el almacenamiento se ha asignado a la textura, los datos de píxeles se pueden cargar a través de una de las sobrecargas de setData().

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

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

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

Una vez que el almacenamiento ha sido asignado ya no es posible cambiar estas propiedades.

Si es compatible, QOpenGLTexture utiliza el almacenamiento de texturas inmutable. Sin embargo, si el almacenamiento de textura inmutable no está disponible, entonces se usarán los especificados pixelFormat y pixelType para asignar almacenamiento mutable; ten en cuenta que en ciertas implementaciones de OpenGL (notablemente, OpenGL ES 2) deben coincidir perfectamente con el formato y el tipo pasado a cualquier llamada subsiguiente a setData().

Una vez que se ha asignado almacenamiento a la textura, los datos de píxeles pueden cargarse mediante una de las sobrecargas de setData().

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

void QOpenGLTexture::bind()

Vincula esta textura a la unidad de textura activa en ese momento, lista para ser renderizada. Ten en cuenta que no necesitas enlazar objetos QOpenGLTexture para modificarlos ya que la implementación hace uso de 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)

Vincula esta textura a la unidad de textura unit lista para ser renderizada. Ten en cuenta que no necesitas enlazar objetos QOpenGLTexture para modificarlos ya que la implementación hace uso de la extensión EXT_direct_state_access cuando está disponible y la simula cuando no lo está.

Si el parámetro reset es true entonces esta función restaurará la unidad activa a la unidad de textura que estaba activa al entrar.

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 del array apuntado por 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 del array apuntado por border.

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

Escribe el color del borde de la textura en los cuatro primeros elementos del array apuntado por border.

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

Devuelve el textureId de la textura que está vinculada al target de la unidad de textura actualmente activa.

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

Devuelve el textureId de la textura que está ligada al target de la unidad de textura unit.

QOpenGLTexture::ComparisonFunction QOpenGLTexture::comparisonFunction() const

Devuelve el operador de comparación de textura establecido en 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 establecido en esta textura. Por defecto, una textura tiene un 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. Esto requiere un contexto OpenGL válido. Si el objeto de textura ya existe, esta función no hace nada.

Una vez creado el objeto textura puedes obtener el nombre del objeto desde la función textureId(). Esto puede ser útil si desea realizar algunas llamadas OpenGL sin procesar 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 textura llaman implícitamente a create() en su nombre.

Devuelve true si la creación tuvo éxito, en caso contrario devuelve false.

Ver 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 algo análogo a una vista en SQL en el sentido de que presenta una vista restringida o reinterpretada de los datos originales. Las vistas de textura no asignan más almacenamiento del lado del servidor, sino que se basan en el búfer de almacenamiento de la textura de origen.

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

El argumento target especifica el objetivo a utilizar para la vista. Sólo se pueden utilizar algunos destinos dependiendo del destino del destino original. Por ejemplo, una vista sobre una textura Target1DArray puede especificar tanto Target1DArray como Target1D, pero para esta última el número de capas de matriz especificadas con minimumLayer y maximumLayer debe ser exactamente 1.

Se aplican restricciones similares a viewFormat. Para más detalles, véase el enlace anterior y la especificación.

Los argumentos minimumMipmapLevel, maximumMipmapLevel, minimumLayer, y maximumLayer sirven para restringir las partes de la textura accesibles por la vista de textura.

Si la creación de la vista de textura falla esta función devolverá 0. Si la función tiene éxito devolverá un puntero a un nuevo objeto QOpenGLTexture que devolverá true de 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 plantilla de profundidad para texturas que utilizan un formato combinado de profundidad/esténcil.

Véase también setDepthStencilMode().

void QOpenGLTexture::destroy()

Destruye el objeto de textura OpenGL subyacente. Esto requiere un contexto OpenGL válido.

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

int QOpenGLTexture::faces() const

Devuelve el número de caras de esta textura. Para objetos de tipo cubemap y cubemap array será 6.

Para objetivos que no sean de tipo cubemap devolverá 1.

QOpenGLTexture::TextureFormat QOpenGLTexture::format() const

Devuelve el formato de este objeto textura.

Véase también setFormat().

void QOpenGLTexture::generateMipMaps()

Genera mipmaps para este objeto de textura desde el nivel 0 de mipmap. Si estás usando un objetivo de textura y una opción de filtrado que requiere mipmaps y has desactivado la generación automática de mipmaps, entonces necesitas llamar a esta función o a la sobrecarga para crear la cadena de mipmaps.

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

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

Genera mipmaps para este objeto de textura desde el nivel de mipmap baseLevel. Si estás utilizando un objetivo de textura y una opción de filtrado que requiere mipmaps y has desactivado la generación automática de mipmaps, entonces necesitas llamar a esta función o a la sobrecarga para crear la cadena de mipmaps.

La generación de mipmaps por encima de baseLevel se consigue estableciendo el nivel base del mipmap en baseLevel y generando a continuación la cadena de mipmaps. Si resetBaseLevel es true, entonces el 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 su implementación y versión de OpenGL admiten la función 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á ligada al objetivo 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á ligada al objetivo correspondiente de la unidad de textura unit.

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

bool QOpenGLTexture::isCreated() const

Devuelve true si el objeto de textura OpenGL subyacente ha sido creado.

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

bool QOpenGLTexture::isFixedSamplePositions() const

Devuelve si esta textura utiliza un patrón fijo de muestras múltiples. Si aún no se ha asignado almacenamiento para esta textura, esta función devuelve el ajuste de posición de muestra fija solicitado.

Para texturas que no soportan multimuestreo esta función devolverá true.

Véase 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, dimensiones, niveles del mipmap y capas del array no pueden ser alterados una vez que el almacenamiento ha sido asignado.

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

bool QOpenGLTexture::isTextureView() const

Devuelve true si este objeto textura es en realidad una vista sobre otro objeto textura.

Ver también createTextureView().

int QOpenGLTexture::layers() const

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

Para texturas que no soportan capas de array esta función devolverá 1.

Ver 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 de nivel de detalle.

Véase también setLevelofDetailBias().

QOpenGLTexture::Filter QOpenGLTexture::magnificationFilter() const

Devuelve el filtro de aumento.

Véase también setMagnificationFilter().

float QOpenGLTexture::maximumAnisotropy() const

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

Véase también setMaximumAnisotropy().

float QOpenGLTexture::maximumLevelOfDetail() const

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

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

int QOpenGLTexture::maximumMipLevels() const

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

Ver también setMipLevels(), mipLevels(), y setSize().

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

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

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 de detalle mínimo.

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

int QOpenGLTexture::mipBaseLevel() const

Devuelve el nivel base del mipmap usado para todas las búsquedas de textura con esta textura. Por defecto es 0.

Ver también setMipBaseLevel(), mipMaxLevel(), y mipLevelRange().

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

Devuelve el rango de niveles mipmap que pueden ser usados para búsquedas de textura con esta textura.

Ver también setMipLevelRange(), mipBaseLevel(), y mipMaxLevel().

int QOpenGLTexture::mipLevels() const

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

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

int QOpenGLTexture::mipMaxLevel() const

Devuelve el nivel máximo de mipmap usado para todas las búsquedas de textura con esta textura.

Ver también setMipMaxLevel(), mipBaseLevel(), y mipLevelRange().

void QOpenGLTexture::release()

Desvincula esta textura de la unidad de textura actualmente activa.

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 entonces esta función restaurará la unidad activa a la unidad de textura que estaba activa al entrar.

int QOpenGLTexture::samples() const

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

Para texturas que no soportan multimuestreo esta función devolverá 0.

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

void QOpenGLTexture::setAutoMipMapGenerationEnabled(bool enabled)

Si enabled es true, habilita la generación automática de mipmap para que este objeto de textura se produzca siempre que los datos de mipmap de nivel 0 se establezcan a través de setData().

La generación automática de mipmap está habilitada por defecto.

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

void QOpenGLTexture::setBorderColor(const QColor &color)

Establece el color del borde de la textura a color.

Véase también borderColor().

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

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

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

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

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

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

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

Establece la función de comparación de texturas en esta textura a function. La función de comparación de texturas es usada por los muestreadores de sombras cuando muestrean una textura de profundidad.

Véase también comparisonFunction().

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

Establece el modo de comparación de texturas en esta textura a mode. El modo de comparación de texturas es usado por los muestreadores de sombras cuando muestrean 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)

Transfiere el píxel comprimido data a mipLevel, array layer, y cubeFace. La transferencia de píxeles puede controlarse opcionalmente con options. El argumento dataSize debe especificar el tamaño de los datos apuntados por data.

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

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)

El parámetro layerCount es el número de capas en un array de texturas que están siendo cargadas/pobladas por esta llamada.

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 el píxel data para este objeto de textura mipLevel, array layer, y cubeFace. El almacenamiento debe haber sido asignado antes de cargar los datos de píxel. Algunas sobrecargas de setData() establecerán las dimensiones apropiadas, niveles de mipmap y capas de array y luego asignarán almacenamiento por ti si tienen suficiente información para hacerlo. Esto se indicará en la documentación de la función.

La estructura de los datos de píxel apuntados por data está especificada por sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante options.

Si utiliza un format() comprimido, deberá utilizar 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() le asignará almacenamiento. Los datos de píxel están contenidos en image. Los mipmaps se generan por defecto. Establezca genMipMaps en DontGenerateMipMaps para desactivar la generación 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)

El parámetro layerCount es el número de capas en un array de texturas que están siendo cargadas/pobladas por esta llamada.

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, zOffset especifican los desplazamientos de texel 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 se especifica en sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante 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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset, 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 de la subimagen que queremos actualizar se especifica con mipLevel.

La estructura de los datos de píxeles apuntados por data se especifica con sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante 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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset, 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 con sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante 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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset, zOffset especifican los desplazamientos del 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 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 con sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante 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)

Esta sobrecarga se utiliza para actualizar una parte de la textura. Los parámetros xOffset, yOffset, 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 apuntados por data se especifica con sourceFormat y sourceType. La carga de datos de píxeles puede controlarse opcionalmente mediante options.

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

Si se utiliza una textura que tiene un formato combinado de profundidad/estencil esta función establece a qué componente de la textura se accede a mode.

Cuando el parámetro se establece en DepthMode, entonces el acceso desde el shader accederá al componente de profundidad como un único flotador, como es normal. Pero cuando el parámetro se establece en StencilMode, el shader accederá al componente stencil.

Véase también depthStencilMode().

void QOpenGLTexture::setFixedSamplePositions(bool fixed)

Establece si las posiciones de muestra y el número de muestras utilizadas con un objetivo de textura capaz de multimuestra a fixed. Si se establece a true las posiciones de muestra y el número de muestras utilizadas son las mismas para todos los texels de la imagen y no dependerán del tamaño de la imagen o del formato interno. Esta función debe invocarse antes de asignar almacenamiento a la textura.

Para los objetivos que no soportan el multimuestreo, esta función no tiene ningún efecto.

El valor por defecto es true.

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

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

Establece el formato de este objeto de textura a format. Esta función debe ser llamada antes de que se asigne el almacenamiento de la textura.

Ten en cuenta que puede que no todos los formatos estén soportados. El conjunto exacto de formatos soportados depende de tu implementación y versión de OpenGL.

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

void QOpenGLTexture::setLayers(int layers)

Establece el número de matrices layers para asignar almacenamiento. Esta función debe ser llamada antes de que el almacenamiento sea asignado a la textura.

Para objetivos que no soportan capas de array esta función no tiene efecto.

Ver también layers() y isStorageAllocated().

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

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

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

void QOpenGLTexture::setLevelofDetailBias(float bias)

Establece el sesgo de nivel de detalle en bias. El sesgo de nivel de detalle afecta al punto en el que cambian los niveles de mapeado. Aumentar los valores del sesgo de nivel de detalle hace que las imágenes globales sean más borrosas o más suaves. Disminuir los valores hace que las imágenes globales sean más nítidas.

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 su implementación de OpenGL soporta 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 máximo nivel de detalle en value. Esto limita la selección del mipmap de menor resolución (máximo nivel de mipmap). El valor por defecto es 1000.

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 por defecto es -1000.

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

void QOpenGLTexture::setMipBaseLevel(int baseLevel)

Establece el nivel base del mipmap usado para todas las búsquedas de textura con esta textura a baseLevel.

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

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

Establece el rango de niveles de mipmap que pueden usarse para buscar texturas con esta textura en un rango de baseLevel a maxLevel.

Ver también setMipBaseLevel(), setMipMaxLevel(), y mipLevelRange().

void QOpenGLTexture::setMipLevels(int levels)

Para objetivos de textura que soportan mipmaps, esta función establece el número solicitado de mipmaps levels para asignar almacenamiento. Esta función debe ser llamada antes de que el almacenamiento sea asignado a la textura.

Si el objetivo de textura no soporta mipmaps esta función no tiene efecto.

Ver también mipLevels(), maximumMipLevels(), y isStorageAllocated().

void QOpenGLTexture::setMipMaxLevel(int maxLevel)

Establece el nivel máximo de mipmap usado para todas las búsquedas de textura con esta textura a maxLevel.

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

void QOpenGLTexture::setSamples(int samples)

Establece el número de samples para asignar almacenamiento cuando se renderiza a un objetivo de textura con capacidad multimuestra. Esta función debe invocarse antes de asignar almacenamiento a la textura.

Para objetivos que no soportan multimuestreo esta función no tiene efecto.

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

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

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

Si se proporciona una textura sin potencia de dos width, height o depth y su implementación OpenGL no tiene soporte para repetir texturas sin potencia de dos, entonces 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 sombreadores GLSL pueden reordenar los componentes del vec4 devuelto por las funciones de textura. También es deseable poder controlar esta reordenación desde el código de la CPU. Esto es posible gracias a las máscaras swizzle desde OpenGL 3.3.

Cada componente de la textura puede ser mapeado a una de las opciones de SwizzleValue.

Esta función mapea component a la salida value.

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 utilizados para establecer los colores rojo, verde, azul y el valor alfa.

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

Establece la envoltura (o modo de repetición) para todas las dimensiones de la textura en mode.

Véase también wrapMode().

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

Establece la envoltura (o modo de repetición) para la dimensión de la textura direction a mode.

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

Devuelve la máscara swizzle para la textura component.

Véase también setSwizzleMask().

QOpenGLTexture::Target QOpenGLTexture::target() const

Devuelve el destino 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().