QRhiTexture Class
Recurso de texturas. Más...
| Encabezado: | #include <rhi/qrhi.h> |
| CMake: | find_package(Qt6 REQUIRED COMPONENTS GuiPrivate) target_link_libraries(mytarget PRIVATE Qt6::GuiPrivate) |
| qmake: | QT += gui-private |
| Desde: | Qt 6.6 |
| Heredado de: | QRhiResource |
Tipos públicos
| struct | NativeTexture |
(since 6.8) struct | ViewFormat |
| enum | Flag { RenderTarget, CubeMap, MipMapped, sRGB, UsedAsTransferSource, …, UsedAsShadingRateMap } |
| flags | Flags |
| enum | Format { UnknownFormat, RGBA8, BGRA8, R8, RG8, …, RGBA32SI } |
Funciones públicas
| int | arrayRangeLength() const |
| int | arrayRangeStart() const |
| int | arraySize() const |
| virtual bool | create() = 0 |
| virtual bool | createFrom(QRhiTexture::NativeTexture src) |
| int | depth() const |
| QRhiTexture::Flags | flags() const |
| QRhiTexture::Format | format() const |
| virtual QRhiTexture::NativeTexture | nativeTexture() |
| QSize | pixelSize() const |
(since 6.8) QRhiTexture::ViewFormat | readViewFormat() const |
| int | sampleCount() const |
| void | setArrayRange(int startIndex, int count) |
| void | setArraySize(int arraySize) |
| void | setDepth(int depth) |
| void | setFlags(QRhiTexture::Flags f) |
| void | setFormat(QRhiTexture::Format fmt) |
| virtual void | setNativeLayout(int layout) |
| void | setPixelSize(const QSize &sz) |
(since 6.8) void | setReadViewFormat(const QRhiTexture::ViewFormat &fmt) |
| void | setSampleCount(int s) |
(since 6.8) void | setWriteViewFormat(const QRhiTexture::ViewFormat &fmt) |
(since 6.8) QRhiTexture::ViewFormat | writeViewFormat() const |
Funciones públicas reimplementadas
| virtual QRhiResource::Type | resourceType() const override |
Descripción detallada
Un objeto QRhiTexture encapsula un objeto de textura nativo, como un VkImage o un MTLTexture.
Una instancia de QRhiTexture siempre se crea llamando a the QRhi's newTexture() function. Esto no crea recursos gráficos nativos. Para ello, hay que llamar a create() tras configurar las opciones adecuadas, como el formato y el tamaño, aunque en la mayoría de los casos estas ya están configuradas en función de los argumentos pasados a newTexture().
Es esencial configurar correctamente ` flags `; de lo contrario, pueden producirse diversos errores en función del backend subyacente de ` QRhi ` y de la API gráfica. Por ejemplo, cuando se va a renderizar una textura desde una pasada de renderizado mediante ` QRhiTextureRenderTarget`, la textura debe crearse con el indicador ` RenderTarget ` activado. Del mismo modo, cuando la textura vaya a ser ` read back`, el indicador ` UsedAsTransferSource ` debe activarse desde el principio. Las texturas con mipmaps deben tener activada la opción « MipMapped ». Y así sucesivamente. No es posible modificar las opciones una vez que « create()» se haya ejecutado con éxito. Para liberar el objeto de textura nativo existente y crear uno nuevo con la configuración modificada, llama a los métodos de configuración y vuelve a llamar a « create()». Esta operación puede resultar potencialmente costosa.
Ejemplo de uso
Para crear una textura 2D con un tamaño de 512x512 píxeles y establecer su contenido en verde:
QRhiTexture *texture = rhi->newTexture(QRhiTexture::RGBA8, QSize(512, 512));
if (!texture->create()) { error(); }
QRhiResourceUpdateBatch *batch = rhi->nextResourceUpdateBatch();
QImage image(512, 512, QImage::Format_RGBA8888);
image.fill(Qt::green);
batch->uploadTexture(texture, image);
// ...
commandBuffer->resourceUpdate(batch); // or, alternatively, pass 'batch' to a beginPass() callPatrones habituales
Una llamada a create() destruye cualquier recurso nativo existente si previamente se ha llamado con éxito a create(). Si esos recursos nativos siguen siendo utilizados por un fotograma en curso (es decir, existe la posibilidad de que la GPU aún los esté leyendo), la destrucción de dichos recursos se aplaza automáticamente. Por lo tanto, un patrón muy común y práctico para cambiar de forma segura el tamaño de una textura ya existente es el siguiente. En la práctica, esto elimina y crea un recurso de textura nativo completamente nuevo en el fondo, por lo que no es necesariamente una operación económica, pero resulta más práctica y aún así más rápida que las alternativas, ya que, al no destruir el propio objeto ` texture `, todas las referencias al mismo siguen siendo válidas en otras estructuras de datos (por ejemplo, en cualquier `QShaderResourceBinding` desde el que se haga referencia a `QRhiTexture`).
// determine newSize, e.g. based on the swapchain's output size or other factors
if (texture->pixelSize() != newSize) {
texture->setPixelSize(newSize);
if (!texture->create()) { error(); }
}
// continue using texture, fill it with new dataNota: Se trata de una API de RHI con garantías de compatibilidad limitadas; consulta QRhi para obtener más detalles.
Véase también QRhiResourceUpdateBatch, QRhi y QRhiTextureRenderTarget.
Documentación sobre los tipos de miembros
enum QRhiTexture::Flag
flags QRhiTexture::Flags
Valores de indicador para especificar cómo se va a utilizar la textura. Si no se respetan los indicadores establecidos antes de create() y se intenta utilizar la textura de formas que no se hayan declarado previamente, puede producirse un comportamiento no especificado o una disminución del rendimiento, dependiendo del backend y de la API gráfica subyacente.
| Constante | Valor | Descripción |
|---|---|---|
QRhiTexture::RenderTarget | 1 << 0 | La textura que se va a utilizar junto con QRhiTextureRenderTarget. |
QRhiTexture::CubeMap | 1 << 2 | La textura es un mapa cúbico. Estas texturas tienen 6 capas, una para cada cara en el orden +X, -X, +Y, -Y, +Z, -Z. Las texturas de mapa cúbico no pueden ser multimuestra. |
QRhiTexture::MipMapped | 1 << 3 | La textura tiene mipmaps. El número adecuado de mips se calcula automáticamente y también se puede obtener mediante ` QRhi::mipLevelsForSize()`. Las imágenes para los niveles de mip deben proporcionarse en la textura cargada o generarse mediante ` QRhiResourceUpdateBatch::generateMips()`. Las texturas con muestreo múltiple no pueden tener mipmaps. |
QRhiTexture::sRGB | 1 << 4 | Utiliza un formato sRGB. |
QRhiTexture::UsedAsTransferSource | 1 << 5 | La textura se utiliza como fuente de una copia o una lectura de textura, lo que significa que la textura se indica como fuente en QRhiResourceUpdateBatch::copyTexture() o QRhiResourceUpdateBatch::readBackTexture(). |
QRhiTexture::UsedWithGenerateMips | 1 << 6 | La textura se va a utilizar con QRhiResourceUpdateBatch::generateMips(). |
QRhiTexture::UsedWithLoadStore | 1 << 7 | La textura se va a utilizar con operaciones de carga/almacenamiento de imágenes, por ejemplo, en un shader de cálculo. |
QRhiTexture::UsedAsCompressedAtlas | 1 << 8 | La textura tiene un formato comprimido y es posible que las dimensiones de las subrecursos cargadas no coincidan con el tamaño de la textura. |
QRhiTexture::ExternalOES | 1 << 9 | La textura debe utilizar el destino GL_TEXTURE_EXTERNAL_OES con OpenGL. Este indicador se ignora con otras API gráficas. |
QRhiTexture::ThreeDimensional | 1 << 10 | La textura es una textura 3D. Este tipo de texturas deben crearse con la sobrecarga de ` QRhi::newTexture()` que toma una profundidad además de la anchura y la altura. Una textura 3D puede tener mipmaps, pero no puede ser multisample. Al renderizar o cargar datos en una textura 3D, el ` layer ` especificado en el anexo de color del destino de renderizado o en la descripción de la carga hace referencia a una única sección dentro del intervalo [0..profundidad-1]. Es posible que la API gráfica subyacente no admita texturas 3D en tiempo de ejecución. La compatibilidad se indica mediante la característica ` QRhi::ThreeDimensionalTextures `. |
QRhiTexture::TextureRectangleGL | 1 << 11 | La textura debe utilizar el destino GL_TEXTURE_RECTANGLE con OpenGL. Este indicador se ignora con otras API gráficas. Al igual que ExternalOES, este indicador resulta útil cuando se trabaja con API de plataforma en las que los objetos de textura OpenGL nativos recibidos de la plataforma se envuelven en un ` QRhiTexture`, y la plataforma solo puede proporcionar texturas para un destino de textura que no sea 2D. |
QRhiTexture::TextureArray | 1 << 12 | La textura es una matriz de texturas, es decir, un único objeto de textura que es una matriz homogénea de texturas 2D. Las matrices de texturas se crean con ` QRhi::newTextureArray()`. Es posible que la API gráfica subyacente no admita objetos de matriz de texturas en tiempo de ejecución. La compatibilidad se indica mediante la característica ` QRhi::TextureArrays `. Al renderizar en una matriz de texturas o al cargar datos en ella, la ` layer ` especificada en el adjunto de color del destino de renderizado o en la descripción de la carga selecciona un único elemento de la matriz. |
QRhiTexture::OneDimensional | 1 << 13 | La textura es una textura unidimensional. Estas texturas se pueden crear pasando una altura y una profundidad de 0 a QRhi::newTexture(). Ten en cuenta que puede haber limitaciones en las texturas unidimensionales dependiendo de la API gráfica subyacente. Por ejemplo, es posible que no se admita renderizarlas o utilizarlas con filtrado basado en mipmaps. Esto se indica mediante los indicadores de características « QRhi::OneDimensionalTextures » y « QRhi::OneDimensionalTextureMipmaps ». |
QRhiTexture::UsedAsShadingRateMap | 1 << 14 |
El tipo Flags es una definición de tipo (typedef) para QFlags<Flag>. Almacena una combinación OR de valores de Flag.
enum QRhiTexture::Format
Especifica el formato de textura. Véase también ` QRhi::isTextureFormatSupported()` y ten en cuenta que ` flags()` puede modificar el formato cuando se establece ` QRhiTexture::sRGB `.
| Constante | Valor | Descripción |
|---|---|---|
QRhiTexture::UnknownFormat | 0 | Formato no válido. No se puede pasar a setFormat(). |
QRhiTexture::RGBA8 | 1 | Cuatro componentes, sin signo y normalizados, de 8 bits por componente. Siempre compatible. (32 bits en total) |
QRhiTexture::BGRA8 | 2 | Cuatro componentes, 8 bits normalizados sin signo por componente. (32 bits en total) |
QRhiTexture::R8 | 3 | Un componente, 8 bits normalizados sin signo. (8 bits en total) |
QRhiTexture::RG8 | 4 | Dos componentes, normalizados sin signo de 8 bits. (16 bits en total) |
QRhiTexture::R16 | 5 | Un componente, 16 bits normalizados sin signo. (16 bits en total) |
QRhiTexture::RG16 | 6 | Dos componentes, normalizados sin signo de 16 bits. (32 bits en total) |
QRhiTexture::RED_OR_ALPHA8 | 7 | Igual que R8 o un formato similar con el componente intercambiado con el alfa, dependiendo de RedOrAlpha8IsRed. (8 bits en total) |
QRhiTexture::RGBA16F | 8 | Cuatro componentes, flotante de 16 bits. (64 bits en total) |
QRhiTexture::RGBA32F | 9 | Cuatro componentes, flotante de 32 bits. (128 bits en total) |
QRhiTexture::R16F | 10 | Un componente, flotante de 16 bits. (16 bits en total) |
QRhiTexture::R32F | 11 | Un componente, flotante de 32 bits. (32 bits en total) |
QRhiTexture::RGB10A2 | 12 | Cuatro componentes: R, G y B normalizados sin signo de 10 bits, y alfa de 2 bits. Se trata de un formato empaquetado, por lo que se aplica el endianismo nativo. Ten en cuenta que no existe el formato BGR10A2. Esto se debe a que RGB10A2 se asigna a DXGI_FORMAT_R10G10B10A2_UNORM con D3D, a MTLPixelFormatRGB10A2Unorm con Metal, VK_FORMAT_A2B10G10R10_UNORM_PACK32 con Vulkan, y GL_RGB10_A2/GL_RGB/GL_UNSIGNED_INT_2_10_10_10_REV en OpenGL (ES). Esta es la única opción RGB30 compatible de forma universal. Los formatos correspondientes de « QImage » son QImage::Format_BGR30 y QImage::Format_A2BGR30_Premultiplied. (32 bits en total) |
QRhiTexture::D16 | 21 | Profundidad de 16 bits (entero sin signo normalizado) |
QRhiTexture::D24 | 22 | Profundidad de 24 bits (entero sin signo normalizado) |
QRhiTexture::D24S8 | 23 | Profundidad de 24 bits (entero sin signo normalizado), plantilla de 8 bits |
QRhiTexture::D32F | 24 | Profundidad de 32 bits (flotante de 32 bits) |
QRhiTexture::D32FS8 (since Qt 6.9) | 25 | Profundidad de 32 bits (número flotante de 32 bits), 8 bits de plantilla, 24 bits sin usar (64 bits en total) |
QRhiTexture::BC1 | 26 | |
QRhiTexture::BC2 | 27 | |
QRhiTexture::BC3 | 28 | |
QRhiTexture::BC4 | 29 | |
QRhiTexture::BC5 | 30 | |
QRhiTexture::BC6H | 31 | |
QRhiTexture::BC7 | 32 | |
QRhiTexture::ETC2_RGB8 | 33 | |
QRhiTexture::ETC2_RGB8A1 | 34 | |
QRhiTexture::ETC2_RGBA8 | 35 | |
QRhiTexture::ASTC_4x4 | 36 | |
QRhiTexture::ASTC_5x4 | 37 | |
QRhiTexture::ASTC_5x5 | 38 | |
QRhiTexture::ASTC_6x5 | 39 | |
QRhiTexture::ASTC_6x6 | 40 | |
QRhiTexture::ASTC_8x5 | 41 | |
QRhiTexture::ASTC_8x6 | 42 | |
QRhiTexture::ASTC_8x8 | 43 | |
QRhiTexture::ASTC_10x5 | 44 | |
QRhiTexture::ASTC_10x6 | 45 | |
QRhiTexture::ASTC_10x8 | 46 | |
QRhiTexture::ASTC_10x10 | 47 | |
QRhiTexture::ASTC_12x10 | 48 | |
QRhiTexture::ASTC_12x12 | 49 | |
QRhiTexture::R8UI (since Qt 6.9) | 17 | Un componente, de 8 bits sin signo. (8 bits en total) |
QRhiTexture::R32UI (since Qt 6.9) | 18 | Un componente, de 32 bits sin signo. (32 bits en total) |
QRhiTexture::RG32UI (since Qt 6.9) | 19 | Dos componentes, de 32 bits sin signo. (64 bits en total) |
QRhiTexture::RGBA32UI (since Qt 6.9) | 20 | Cuatro componentes, de 32 bits sin signo. (128 bits en total) |
QRhiTexture::R8SI (since Qt 6.10) | 13 | Un componente, de 8 bits con signo. (8 bits en total) |
QRhiTexture::R32SI (since Qt 6.10) | 14 | Un componente, de 32 bits con signo. (32 bits en total) |
QRhiTexture::RG32SI (since Qt 6.10) | 15 | Dos componentes, de 32 bits con signo. (64 bits en total) |
QRhiTexture::RGBA32SI (since Qt 6.10) | 16 | Cuatro componentes, de 32 bits sin signo. (128 bits en total) |
Documentación de las funciones de miembro
int QRhiTexture::arrayRangeLength() const
Devuelve el tamaño del rango de la matriz expuesta cuando se llamó a setArrayRange().
Véase también ` setArrayRange()`.
int QRhiTexture::arrayRangeStart() const
Devuelve la primera capa de matriz cuando se ha llamado a setArrayRange().
Véase también ` setArrayRange()`.
int QRhiTexture::arraySize() const
Devuelve el tamaño de la matriz de texturas.
Véase también ` setArraySize()`.
[pure virtual] bool QRhiTexture::create()
Crea los recursos gráficos nativos correspondientes. Si ya existen recursos debido a una llamada previa a `create()` sin el correspondiente ` destroy()`, entonces se llama primero de forma implícita a ` destroy()`.
Devuelve ` true ` si se realiza correctamente, y ` false ` si falla una operación gráfica. Independientemente del valor devuelto, llamar a ` destroy()` siempre es seguro.
[virtual] bool QRhiTexture::createFrom(QRhiTexture::NativeTexture src)
Es similar a ` create()`, salvo que no se crean nuevas texturas nativas. En su lugar, se utilizan los recursos de texturas nativas especificados por ` src `.
Esto permite importar un objeto de textura nativa ya existente (que debe pertenecer al mismo dispositivo o contexto compartido, dependiendo de la API gráfica) desde un motor gráfico externo.
Devuelve «true» si el objeto de textura nativa existente especificado se ha envuelto correctamente como un ` QRhiTexture` sin propiedad.
Nota: format(), pixelSize(), sampleCount() y flags() deben seguir configurándose correctamente. Pasar tamaños u otros valores incorrectos a QRhi::newTexture() y, a continuación, llamar a createFrom() esperando que el objeto de textura nativo por sí solo sea suficiente para deducir dichos valores es un error y provocará problemas.
Nota: ` QRhiTexture ` no asume la propiedad del objeto de textura. ` destroy()` no libera el objeto ni ninguna memoria asociada.
La operación inversa, es decir, exponer un objeto de textura nativo creado por QRhiTexture a un motor externo, es posible mediante nativeTexture().
Nota: Al importar una textura 3D, un objeto de matriz de texturas o, con OpenGL ES, una textura externa, es especialmente importante establecer los indicadores correspondientes (ThreeDimensional, TextureArray, ExternalOES) mediante setFlags() antes de llamar a esta función.
int QRhiTexture::depth() const
Devuelve la profundidad de las texturas 3D.
Véase también setDepth().
QRhiTexture::Flags QRhiTexture::flags() const
Devuelve los indicadores de textura.
Véase también setFlags().
QRhiTexture::Format QRhiTexture::format() const
Devuelve el formato de la textura.
Véase también setFormat().
[virtual] QRhiTexture::NativeTexture QRhiTexture::nativeTexture()
Devuelve los recursos nativos subyacentes de esta textura. El valor devuelto estará vacío si el backend no admite la exposición de los recursos nativos subyacentes.
Véase también createFrom().
QSize QRhiTexture::pixelSize() const
Devuelve el tamaño en píxeles.
Véase también setPixelSize().
[since 6.8] QRhiTexture::ViewFormat QRhiTexture::readViewFormat() const
Devuelve el formato de vista utilizado al muestrear la textura. Si no se invoca esta función, se da por hecho que el formato de vista es el mismo que el de ` format()`.
Esta función se introdujo en Qt 6.8.
Véase también ` setReadViewFormat()`.
[override virtual] QRhiResource::Type QRhiTexture::resourceType() const
Reimplementa: ` QRhiResource::resourceType()` const.
Devuelve el tipo de recurso.
int QRhiTexture::sampleCount() const
Devuelve el número de muestras. El valor 1 indica que no se aplica antialiasing multimuestra.
Véase también setSampleCount().
void QRhiTexture::setArrayRange(int startIndex, int count)
Normalmente, todas las capas de la matriz quedan expuestas y es el shader el que debe seleccionar la capa mediante la tercera coordenada que se pasa a la función GLSL « texture() » al muestrear « sampler2DArray ». Cuando se indica que « QRhi::TextureArrayRange » es compatible, al llamar a «setArrayRange()» antes de « create()» o « createFrom()» se solicita que se seleccione únicamente el rango especificado, « count » elementos a partir de « startIndex ». La lógica del shader puede escribirse teniendo esto en cuenta.
Véase también QRhi::TextureArrayRange.
void QRhiTexture::setArraySize(int arraySize)
Establece la textura « arraySize ».
Véase también arraySize().
void QRhiTexture::setDepth(int depth)
Establece el valor de « depth » para una textura 3D.
Véase también depth().
void QRhiTexture::setFlags(QRhiTexture::Flags f)
Establece los indicadores de textura en « f ».
Véase también ` flags()`.
void QRhiTexture::setFormat(QRhiTexture::Format fmt)
Establece el formato de textura solicitado en « fmt ».
Nota: El valor establecido solo se tiene en cuenta en la siguiente llamada a create(), es decir, cuando se (re)crea el recurso gráfico subyacente. Establecer un nuevo valor es inútil en cualquier otro caso y debe evitarse, ya que puede provocar un estado incoherente.
Véase también format().
[virtual] void QRhiTexture::setNativeLayout(int layout)
Con algunas API gráficas, como Vulkan, la integración de código de renderizado personalizado que utilice directamente la API gráfica requiere una atención especial en lo que respecta a la disposición de las imágenes. Esta función permite indicar el layout esperado en el que se encuentra la imagen subyacente a QRhiTexture tras la ejecución de los comandos de renderizado nativos.
Por ejemplo, imaginemos que se realiza un renderizado directamente en un `VkImage` de un ` QRhiTexture` con Vulkan, en un bloque de código delimitado por ` QRhiCommandBuffer::beginExternal()` y ` QRhiCommandBuffer::endExternal()`, y que a continuación se utiliza la imagen para el muestreo de texturas en una pasada de renderizado basada en ` QRhi`. Para evitar transiciones potencialmente incorrectas en el diseño de la imagen, esta función puede utilizarse para indicar cuál será el diseño de la imagen una vez que se hayan completado los comandos registrados en dicho bloque de código.
Solo tiene sentido llamar a esta función después de QRhiCommandBuffer::endExternal() y antes de un QRhiCommandBuffer::beginPass() posterior.
Esta función no tiene ningún efecto con los backends de ` QRhi ` en los que la API gráfica subyacente no expone el concepto de diseños de imagen.
Nota: Con Vulkan, ` layout ` es un ` VkImageLayout`. Con Direct 3D 12, ` layout ` es un valor compuesto por los bits de ` D3D12_RESOURCE_STATES`.
void QRhiTexture::setPixelSize(const QSize &sz)
Establece el tamaño de la textura, expresado en píxeles, en sz.
Nota: El valor establecido solo se tiene en cuenta en la siguiente llamada a ` create()`, es decir, cuando se (re)crea el recurso gráfico subyacente. Establecer un nuevo valor es inútil en cualquier otro caso y debe evitarse, ya que puede provocar un estado incoherente. Lo mismo se aplica al resto de métodos de configuración.
Véase también pixelSize().
[since 6.8] void QRhiTexture::setReadViewFormat(const QRhiTexture::ViewFormat &fmt)
Establece el formato de visualización del recurso de shader (o el formato de la vista utilizada para el muestreo de la textura) en « fmt ». Por defecto, se utiliza el mismo formato (y el mismo espacio de color sRGB) que el de la propia textura, por lo que, en la mayoría de los casos, no es necesario llamar a esta función.
Esta configuración solo se tiene en cuenta cuando se indica que la función « QRhi::TextureViewFormat » es compatible.
Nota: Esta funcionalidad se proporciona para permitir la «conversión» entre formatos que no sean sRGB y sRGB, con el fin de que las lecturas del sombreador realicen —o no realicen— las conversiones sRGB implícitas. Es posible que otros tipos de conversión funcionen o no.
Esta función se introdujo en Qt 6.8.
Véase también readViewFormat().
void QRhiTexture::setSampleCount(int s)
Establece el número de muestras en s.
Véase también sampleCount().
[since 6.8] void QRhiTexture::setWriteViewFormat(const QRhiTexture::ViewFormat &fmt)
Establece el formato de vista del destino de renderizado en « fmt ». Por defecto, se utiliza el mismo formato (y el mismo espacio de color sRGB) que el de la propia textura, por lo que, en la mayoría de los casos, no es necesario llamar a esta función.
Un caso de uso habitual para proporcionar un formato de vista de escritura es trabajar con texturas proporcionadas externamente que, fuera de nuestro control, utilizan un formato sRGB con API 3D como Vulkan o Direct 3D, pero el motor de renderizado ya está preparado para gestionar la linealización y la conversión a sRGB al final de su canal de sombreado. En este caso, lo que se desea al renderizar en una textura de este tipo es una vista de destino de renderizado (por ejemplo, VkImageView) que tenga el mismo formato, pero que no sea sRGB. (Si, por ejemplo, a partir de una implementación de OpenXR se obtiene una textura VK_FORMAT_R8G8B8A8_SRGB, es probable que el renderizado en ella deba realizarse utilizando una vista VK_FORMAT_R8G8B8A8_UNORM, si eso es lo que requiere el proceso del motor de renderizado; en este ejemplo, se llamaría a esta función con un ` ViewFormat ` que tenga un formato de ` QRhiTexture::RGBA8 ` y ` srgb ` establecido en ` false`).
Esta configuración solo se tiene en cuenta cuando se indica que la función « QRhi::TextureViewFormat » es compatible.
Nota: Esta funcionalidad se proporciona para permitir la «conversión» entre espacios de color no sRGB y sRGB, con el fin de que la escritura del shader no realice, o sí realice, las conversiones sRGB implícitas. Otros tipos de conversión pueden funcionar o no.
Esta función se introdujo en Qt 6.8.
Véase también writeViewFormat().
[since 6.8] QRhiTexture::ViewFormat QRhiTexture::writeViewFormat() const
Devuelve el formato de vista utilizado al escribir en la textura y al utilizarla con las funciones de carga y almacenamiento de imágenes. Si no se invoca esta función, se supone que el formato de vista es el mismo que el de ` format()`.
Esta función se introdujo en Qt 6.8.
Véase también ` setWriteViewFormat()`.
© 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.