QRhiSwapChain Class
Recurso de Swapchain. 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
| enum | Flag { SurfaceHasPreMulAlpha, SurfaceHasNonPreMulAlpha, sRGB, UsedAsTransferSource, NoVSync, MinimalBufferCount } |
| flags | Flags |
| enum | Format { SDR, HDRExtendedSrgbLinear, HDR10, HDRExtendedDisplayP3Linear } |
| enum | StereoTargetBuffer { LeftBuffer, RightBuffer } |
Funciones públicas
| virtual bool | createOrResize() = 0 |
| virtual QRhiCommandBuffer * | currentFrameCommandBuffer() = 0 |
| virtual QRhiRenderTarget * | currentFrameRenderTarget() = 0 |
| virtual QRhiRenderTarget * | currentFrameRenderTarget(QRhiSwapChain::StereoTargetBuffer targetBuffer) |
| QSize | currentPixelSize() const |
| QRhiRenderBuffer * | depthStencil() const |
| QRhiSwapChain::Flags | flags() const |
| QRhiSwapChain::Format | format() const |
| virtual QRhiSwapChainHdrInfo | hdrInfo() |
| virtual bool | isFormatSupported(QRhiSwapChain::Format f) = 0 |
| virtual QRhiRenderPassDescriptor * | newCompatibleRenderPassDescriptor() = 0 |
| QRhiSwapChainProxyData | proxyData() const |
| QRhiRenderPassDescriptor * | renderPassDescriptor() const |
| int | sampleCount() const |
| void | setDepthStencil(QRhiRenderBuffer *ds) |
| void | setFlags(QRhiSwapChain::Flags f) |
| void | setFormat(QRhiSwapChain::Format f) |
| void | setProxyData(const QRhiSwapChainProxyData &d) |
| void | setRenderPassDescriptor(QRhiRenderPassDescriptor *desc) |
| void | setSampleCount(int samples) |
(since 6.9) void | setShadingRateMap(QRhiShadingRateMap *map) |
| void | setWindow(QWindow *window) |
(since 6.9) QRhiShadingRateMap * | shadingRateMap() const |
| virtual QSize | surfacePixelSize() = 0 |
| QWindow * | window() const |
Funciones públicas reimplementadas
| virtual QRhiResource::Type | resourceType() const override |
Descripción detallada
Una cadena de intercambio permite presentar los resultados del renderizado en una superficie. Una cadena de intercambio suele estar respaldada por un conjunto de búferes de color. De estos, solo se muestra uno a la vez.
A continuación se muestra un patrón típico para crear y gestionar una cadena de intercambio y algunos recursos asociados con el fin de renderizar en una superficie de renderizado ( QWindow):
void init()
{
sc = rhi->newSwapChain();
ds = rhi->newRenderBuffer(QRhiRenderBuffer::DepthStencil,
QSize(), // no need to set the size here due to UsedWithSwapChainOnly
1,
QRhiRenderBuffer::UsedWithSwapChainOnly);
sc->setWindow(window);
sc->setDepthStencil(ds);
rp = sc->newCompatibleRenderPassDescriptor();
sc->setRenderPassDescriptor(rp);
resizeSwapChain();
}
void resizeSwapChain()
{
hasSwapChain = sc->createOrResize();
}
void render()
{
if (!hasSwapChain || notExposed)
return;
if (sc->currentPixelSize() != sc->surfacePixelSize() || newlyExposed) {
resizeSwapChain();
if (!hasSwapChain)
return;
newlyExposed = false;
}
rhi->beginFrame(sc);
// ...
rhi->endFrame(sc);
}Evita basarte en los eventos de redimensionamiento de la superficie ( QWindow ) para redimensionar las cadenas de intercambio, sobre todo teniendo en cuenta que los tamaños de las superficies pueden no coincidir siempre por completo con las dimensiones indicadas por el objeto de superficie ( QWindow ). El enfoque seguro y multiplataforma consiste en realizar la comprobación mediante ` surfacePixelSize()` cada vez que se inicie un nuevo fotograma.
La liberación de la cadena de intercambio debe realizarse mientras el QWindow y la ventana nativa subyacente estén plenamente activos y en funcionamiento. Partiendo del ejemplo anterior:
void releaseSwapChain()
{
if (hasSwapChain) {
sc->destroy();
hasSwapChain = false;
}
}
// assuming Window is our QWindow subclass
bool Window::event(QEvent *e)
{
switch (e->type()) {
case QEvent::UpdateRequest: // for QWindow::requestUpdate()
render();
break;
case QEvent::PlatformSurface:
if (static_cast<QPlatformSurfaceEvent *>(e)->surfaceEventType() == QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed)
releaseSwapChain();
break;
default:
break;
}
return QWindow::event(e);
}La inicialización de la cadena de intercambio y el inicio del renderizado del primer fotograma no pueden comenzar en cualquier momento. El enfoque seguro y multiplataforma consiste en basarse en los eventos «expose». « QExposeEvent » es un evento de especificación flexible que se envía cada vez que una ventana se asigna, se oculta o se redimensiona, dependiendo de la plataforma.
void Window::exposeEvent(QExposeEvent *)
{
// initialize and start rendering when the window becomes usable for graphics purposes
if (isExposed() && !running) {
running = true;
init();
}
// stop pushing frames when not exposed or size becomes 0
if ((!isExposed() || (hasSwapChain && sc->surfacePixelSize().isEmpty())) && running)
notExposed = true;
// continue when exposed again and the surface has a valid size
if (isExposed() && running && notExposed && !sc->surfacePixelSize().isEmpty()) {
notExposed = false;
newlyExposed = true;
}
if (isExposed() && !sc->surfacePixelSize().isEmpty())
render();
}Una vez que ha comenzado el renderizado, una forma sencilla de solicitar un nuevo fotograma es mediante ` QWindow::requestUpdate()`. Aunque en algunas plataformas se trata simplemente de un pequeño temporizador, en otras tiene una implementación específica: por ejemplo, en macOS o iOS puede estar respaldado por `CVDisplayLink`. El ejemplo anterior ya está preparado para las solicitudes de actualización al gestionar ` QEvent::UpdateRequest`.
Además de actuar como un « QRhiRenderTarget », QRhiSwapChain también gestiona un « QRhiCommandBuffer ». Al llamar a QRhi::endFrame(), se envían los comandos grabados y, además, se pone en cola una solicitud de « present ». El comportamiento por defecto es hacerlo con un intervalo de intercambio de 1, lo que significa que la sincronización con la frecuencia de actualización vertical de la pantalla está habilitada. Por lo tanto, el hilo de renderizado que llama a `beginFrame()` y `endFrame()` se verá limitado por la sincronización vertical (vsync). En algunos backends, esto se puede desactivar pasando `QRhiSwapChain:NoVSync ` en ` flags()`.
El multimuestreo (MSAA) se gestiona de forma transparente para las aplicaciones cuando se solicita mediante setSampleCount(). Cuando sea aplicable, QRhiSwapChain se encargará de crear búferes de color adicionales y de emitir un comando de resolución de multimuestreo al final de un fotograma. En el caso de OpenGL, es necesario solicitar el recuento de muestras adecuado también a través de QSurfaceFormat, llamando a QSurfaceFormat::setDefaultFormat() antes de inicializar QRhi.
Nota: Se trata de una API de RHI con garantías de compatibilidad limitadas; consulta QRhi para obtener más detalles.
Documentación sobre los tipos de miembros
enum QRhiSwapChain::Flag
flags QRhiSwapChain::Flags
Valores de los indicadores para describir las propiedades de la cadena de intercambio
| Constante | Valor | Descripción |
|---|---|---|
QRhiSwapChain::SurfaceHasPreMulAlpha | 1 << 0 | Indica que la superficie de destino tiene transparencia con alfa premultiplicado. Por ejemplo, esto es lo que utiliza Qt Quick cuando el canal alfa está habilitado en el destino QWindow, ya que el renderizador del grafo de escena siempre genera fragmentos con el alfa multiplicado en los valores de rojo, verde y azul. Para garantizar un comportamiento idéntico en todas las plataformas, establece siempre QSurfaceFormat::alphaBufferSize() en un valor distinto de cero en la superficie de destino QWindow siempre que este indicador esté activado en la cadena de intercambio. |
QRhiSwapChain::SurfaceHasNonPreMulAlpha | 1 << 1 | Indica que la superficie de destino tiene transparencia con alfa no premultiplicado. Ten en cuenta que es posible que esto no sea compatible en algunos sistemas, si el compositor del sistema siempre espera contenido con alfa premultiplicado. En ese caso, se espera que el comportamiento con este indicador activado sea equivalente al de `SurfaceHasPreMulAlpha`. |
QRhiSwapChain::sRGB | 1 << 2 | Solicita que se elija un formato sRGB para los búferes de color de la cadena de intercambio y/o las vistas del destino de renderizado, cuando sea aplicable. Tenga en cuenta que esto implica que se habilitarán la actualización y la mezcla del búfer de fotogramas sRGB para todo el contenido destinado a esta cadena de intercambio, y no es posible desactivarlo. Para OpenGL, establezca además ` sRGBColorSpace ` en el ` QSurfaceFormat ` del ` QWindow `. Aplicable únicamente cuando el formato de la cadena de intercambio está establecido en ` QRhiSwapChain::SDR`. |
QRhiSwapChain::UsedAsTransferSource | 1 << 3 | Indica que la cadena de intercambio se utilizará como fuente de una lectura posterior en QRhiResourceUpdateBatch::readBackTexture(). |
QRhiSwapChain::NoVSync | 1 << 4 | Solicita que se desactive la espera de la sincronización vertical, evitando así la limitación del hilo de renderizado. El comportamiento depende del backend y solo es aplicable cuando es posible controlarlo. Algunos pueden ignorar la solicitud por completo. Para OpenGL, prueba en su lugar a establecer el intervalo de intercambio en 0 en QWindow mediante QSurfaceFormat::setSwapInterval(). |
QRhiSwapChain::MinimalBufferCount | 1 << 5 | Solicita que se cree la cadena de intercambio con el número mínimo de búferes, que en la práctica es 2, a menos que la implementación gráfica tenga un número mínimo superior a ese. Solo es aplicable en backends en los que se dispone de dicho control a través de la API gráfica, por ejemplo, Vulkan. Por defecto, corresponde al backend decidir el número de búferes que solicita (en la práctica, casi siempre es 2 o 3), y no es responsabilidad de la aplicación. Sin embargo, en Vulkan, por ejemplo, es probable que el backend prefiera el número más alto (3), por ejemplo, para evitar problemas de rendimiento inusuales con algunas implementaciones de Vulkan en dispositivos móviles. Podría darse el caso de que, en algunas plataformas, resulte beneficioso forzar el número más bajo de búferes (2), por lo que este indicador permite forzarlo. Ten en cuenta que todo esto no tiene ningún efecto sobre el número de fotogramas que se mantienen en proceso, por lo que la CPU (QRhi) seguirá preparando fotogramas con una antelación máxima de N - 1 respecto a la GPU, incluso cuando el número de búferes de imagen de la cadena de intercambio sea mayor que N. (N = QRhi::FramesInFlight y, por lo general, 2). |
El tipo «Flags» es un `typedef` para ` QFlags<Flag>`. Almacena una combinación OR de valores de `Flag`.
enum QRhiSwapChain::Format
Describe el formato de la cadena de intercambio. El formato predeterminado es SDR.
Esta enumeración se utiliza con ` isFormatSupported()` para comprobar de antemano si la plataforma y la pantalla asociada a la ventana admiten la creación de la cadena de intercambio con el formato indicado, y con ` setFormat()` para establecer el formato solicitado en la cadena de intercambio antes de llamar a ` createOrResize()` por primera vez.
| Constante | Valor | Descripción |
|---|---|---|
QRhiSwapChain::SDR | 0 | RGBA o BGRA de 8 bits, dependiendo del backend y de la plataforma. Con OpenGL ES en particular, podría ocurrir que la plataforma proporcione menos de 8 bits (por ejemplo, debido a que EGL y la función QSurfaceFormat elijan un formato 565 o 444; esto escapa al control de QRhi). Rango dinámico estándar. Se puede combinar con la configuración del indicador « QRhiSwapChain::sRGB ». |
QRhiSwapChain::HDRExtendedSrgbLinear | 1 | RGBA de 16 bits en coma flotante, alto rango dinámico, espacio de color sRGB lineal ampliado (scRGB). Esto implica primarios Rec. 709 (iguales que en SDR/sRGB) y colores lineales. La conversión al espacio de color nativo de la pantalla (como, por ejemplo, HDR10) la realiza el sistema de ventanas. En Windows, este es el espacio de color canónico del compositor del sistema, y es el formato recomendado para las cadenas de intercambio HDR en general en plataformas de escritorio. |
QRhiSwapChain::HDR10 | 2 | RGB o BGR de 10 bits sin signo con 2 bits de alfa, alto rango dinámico, espacio de color HDR10 (Rec. 2020) con una función de transferencia PQ ST2084. |
QRhiSwapChain::HDRExtendedDisplayP3Linear | 3 | RGBA de 16 bits en formato flotante, alto rango dinámico, espacio de color Display P3 lineal extendido. La opción principal para el HDR en plataformas como iOS y VisionOS. |
enum QRhiSwapChain::StereoTargetBuffer
Selecciona el búfer de fondo que se utilizará con una cadena de intercambio estereoscópica.
| Constante | Valor |
|---|---|
QRhiSwapChain::LeftBuffer | 0 |
QRhiSwapChain::RightBuffer | 1 |
Documentación de la función miembro
[pure virtual] bool QRhiSwapChain::createOrResize()
Crea la cadena de intercambio si aún no se ha hecho y redimensiona los búferes de la cadena de intercambio para que se ajusten al tamaño actual de la superficie de destino. Llama a esta función siempre que el tamaño de la superficie de destino sea diferente al anterior.
Nota: llama a ` destroy()` solo cuando sea necesario liberar completamente la cadena de intercambio, normalmente al llamar a ` QPlatformSurfaceEvent::SurfaceAboutToBeDestroyed`. Para cambiar el tamaño, basta con llamar a `createOrResize()`.
Devuelve ` true ` si se realiza correctamente, y ` false ` si ha fallado una operación gráfica. Independientemente del valor devuelto, llamar a ` destroy()` siempre es seguro.
[pure virtual] QRhiCommandBuffer *QRhiSwapChain::currentFrameCommandBuffer()
Devuelve un búfer de comandos en el que se pueden registrar comandos de renderizado y actualizaciones de recursos dentro de un bloque « beginFrame » - « endFrame », siempre que se haya llamado a `beginFrame()` con esta cadena de intercambio.
Nota: El objeto devuelto sigue siendo válido tras la llamada a `endFrame()`, hasta la siguiente llamada a `beginFrame()`, pero el búfer de comandos devuelto no debe utilizarse para registrar ningún comando en ese momento. En cambio, puede utilizarse para consultar los datos recopilados durante el fotograma (o fotogramas anteriores), por ejemplo, llamando a ` lastCompletedGpuTime()`.
Nota: El valor no debe almacenarse en caché ni reutilizarse entre fotogramas. El llamante no debe conservar el objeto devuelto una vez que se vuelva a llamar a beginFrame(). En su lugar, el objeto del búfer de comandos debe consultarse de nuevo llamando a esta función.
[pure virtual] QRhiRenderTarget *QRhiSwapChain::currentFrameRenderTarget()
Devuelve un destino de renderizado que se puede utilizar con `beginPass()` para renderizar el backbuffer actual de la cadena de intercambio. Solo es válido dentro de un bloque ` QRhi::beginFrame()` - ` QRhi::endFrame()` en el que se haya llamado a `beginFrame()` con esta cadena de intercambio.
Nota: el valor no debe almacenarse en caché ni reutilizarse entre fotogramas.
[virtual] QRhiRenderTarget *QRhiSwapChain::currentFrameRenderTarget(QRhiSwapChain::StereoTargetBuffer targetBuffer)
Devuelve un destino de renderizado que se puede utilizar con `beginPass()` para renderizar en el búfer de fondo izquierdo o derecho de la cadena de intercambio. Esta sobrecarga solo debe utilizarse con el renderizado estereoscópico, es decir, cuando la cadena de intercambio ( QWindow ) asociada cuenta con dos búferes de color, uno para cada ojo, en lugar de uno solo.
Cuando no se admite el renderizado estereoscópico, el valor devuelto será el destino predeterminado. Es compatible con todos los backends de hardware, excepto Metal, en combinación con QSurfaceFormat::StereoBuffers, siempre que sea compatible con la pila de controladores gráficos y de pantalla en tiempo de ejecución. Los backends Metal y Null devolverán el destino de renderizado predeterminado desde esta sobrecarga.
Nota: el valor no debe almacenarse en caché ni reutilizarse entre fotogramas.
QSize QRhiSwapChain::currentPixelSize() const
Devuelve el tamaño con el que se creó por última vez con éxito la cadena de intercambio. Utiliza esto para decidir si es necesario volver a llamar a ` createOrResize()`: si ` currentPixelSize() != surfacePixelSize() `, entonces hay que cambiar el tamaño de la cadena de intercambio.
Nota: La lógica de renderizadohabitual llamará a esta función para obtener el tamaño de salida al comenzar a preparar un nuevo fotograma, y basará los cálculos dependientes (como la ventana de visualización) en el tamaño devuelto por esta función.
Aunque en muchos casos el valor es el mismo que el de ` QWindow::size() * QWindow::devicePixelRatio()`, no se garantiza que el tamaño indicado por ` QWindow` sea correcto en todas las plataformas e implementaciones de API gráficas. Por lo tanto, se recomienda encarecidamente utilizar esta función siempre que sea necesario identificar las dimensiones, en píxeles, de la capa o superficie de salida.
Esto también tiene la ventaja añadida de evitar posibles conflictos de acceso a datos cuando se utiliza ` QRhi ` en un hilo de renderizado dedicado, ya que se evita la necesidad de llamar a funciones de ` QWindow `, que podrían acceder a datos actualizados en el hilo principal.
Véase también surfacePixelSize().
QRhiRenderBuffer *QRhiSwapChain::depthStencil() const
Devuelve el búfer de renderizado asociado actualmente para profundidad-estencil.
Véase también setDepthStencil().
QRhiSwapChain::Flags QRhiSwapChain::flags() const
Devuelve los indicadores establecidos actualmente.
Véase también setFlags().
QRhiSwapChain::Format QRhiSwapChain::format() const
Devuelve el formato establecido actualmente.
Véase también setFormat().
[virtual] QRhiSwapChainHdrInfo QRhiSwapChain::hdrInfo()
Devuelve la información HDR de la pantalla asociada.
No se debe dar por sentado que se trata de una operación de bajo coste. Dependiendo de la plataforma, esta función realiza diversas consultas al sistema que pueden afectar al rendimiento.
Nota: Se puede llamar antes de ` createOrResize()` siempre que la ventana sea ` set`.
Nota: Lo que ocurre al mover una ventana con una cadena de intercambio (swapchain) inicializada entre pantallas (de HDR a HDR con características diferentes, de HDR a SDR, etc.) no está bien definido actualmente y depende en gran medida del sistema de ventanas y del compositor, con un comportamiento que puede variar entre plataformas. Actualmente, ` QRhi ` solo garantiza que `hdrInfo()` devuelva datos válidos, si están disponibles, para la pantalla a la que pertenecía la ventana asociada a la cadena de intercambio en el momento de llamar a ` createOrResize()`.
Véase también QRhiSwapChainHdrInfo.
[pure virtual] bool QRhiSwapChain::isFormatSupported(QRhiSwapChain::Format f)
Devuelve «true» si se admite el formato de swapchain indicado f. SDR siempre es compatible.
Nota: Se puede invocar independientemente de createOrResize(), pero window() debe estar ya establecido. Llamarla sin haber configurado la ventana puede dar lugar a resultados inesperados dependiendo del backend y la plataforma (lo más probable es que devuelva «false» para cualquier formato HDR), ya que la compatibilidad con el formato HDR suele estar vinculada a la salida (pantalla) a la que pertenece la ventana asociada a la cadena de intercambio en un momento dado. Si el resultado es «true» para un formato HDR, se espera que la creación de la cadena de intercambio con ese formato se realice con éxito, siempre y cuando la ventana no se haya movido a otra pantalla mientras tanto.
El uso principal de esta función es llamarla antes de la primera llamada a ` createOrResize()` una vez que la ventana ya está configurada. Esto permite a los backends de ` QRhi ` realizar consultas específicas de la plataforma o del sistema de ventanas para determinar si la ventana (y la pantalla en la que se encuentra) es capaz de ofrecer una salida HDR auténtica con el formato especificado.
Cuando se indique que el formato es compatible, llama a ` setFormat()` para establecer el formato solicitado y llama a ` createOrResize()`. No obstante, ten en cuenta las consecuencias: solicitar con éxito un formato HDR implicará tener que lidiar con un espacio de color diferente, posiblemente realizar una corrección del nivel de blanco para contenidos no compatibles con HDR, ajustar los métodos de mapeo de tonos, ajustar la configuración del destino de renderizado fuera de pantalla, etc.
Véase también setFormat().
[pure virtual] QRhiRenderPassDescriptor *QRhiSwapChain::newCompatibleRenderPassDescriptor()
Devuelve un nuevo objeto ` QRhiRenderPassDescriptor ` que es compatible con esta cadena de intercambio.
El valor devuelto se utiliza de dos formas: puede pasarse a ` setRenderPassDescriptor()` y a ` QRhiGraphicsPipeline::setRenderPassDescriptor()`. Un descriptor de pasada de renderizado describe los adjuntos (color, profundidad/plantilla) y el comportamiento de carga/almacenamiento que puede verse afectado por ` flags()`. Un ` QRhiGraphicsPipeline ` solo puede utilizarse en combinación con una cadena de intercambio que tenga un ` compatible ` QRhiRenderPassDescriptor establecido.
Véase también createOrResize().
QRhiSwapChainProxyData QRhiSwapChain::proxyData() const
Devuelve los datos del proxy configurados actualmente.
Véase también setProxyData().
QRhiRenderPassDescriptor *QRhiSwapChain::renderPassDescriptor() const
Devuelve el objeto ` QRhiRenderPassDescriptor ` asociado actualmente.
Véase también setRenderPassDescriptor().
[override virtual] QRhiResource::Type QRhiSwapChain::resourceType() const
Reimplementa: ` QRhiResource::resourceType()` const.
Devuelve el tipo de recurso.
int QRhiSwapChain::sampleCount() const
Devuelve el número de muestras establecido actualmente. El valor 1 indica que no se aplica antialiasing por multimuestra.
Véase también setSampleCount().
void QRhiSwapChain::setDepthStencil(QRhiRenderBuffer *ds)
Establece el búfer de renderizado ds para utilizarlo como búfer de profundidad-estencil.
Véase también depthStencil().
void QRhiSwapChain::setFlags(QRhiSwapChain::Flags f)
Establece los indicadores « f ».
Véase también flags().
void QRhiSwapChain::setFormat(QRhiSwapChain::Format f)
Establece el formato f.
Evita establecer formatos que, según isFormatSupported(), no sean compatibles. Ten en cuenta que la compatibilidad con un formato determinado puede depender de la pantalla en la que se abra la ventana asociada a la cadena de intercambio. En algunas plataformas, como Windows y macOS, para que la salida HDR funcione es necesario tenerla activada en la configuración de la pantalla.
Consulte isFormatSupported(), QRhiSwapChainHdrInfo y Format para obtener más información sobre la salida de alto rango dinámico.
Véase también format().
void QRhiSwapChain::setProxyData(const QRhiSwapChainProxyData &d)
Establece los datos del proxy d.
Véase también proxyData() y QRhi::updateSwapChainProxyData().
void QRhiSwapChain::setRenderPassDescriptor(QRhiRenderPassDescriptor *desc)
Colabora con la QRhiRenderPassDescriptor desc .
Véase también renderPassDescriptor().
void QRhiSwapChain::setSampleCount(int samples)
Establece el número de muestras. Los valores habituales para « samples » son 1 (sin MSAA), 4 (MSAA de 4x) u 8 (MSAA de 8x).
Véase también sampleCount() y QRhi::supportedSampleCounts().
[since 6.9] void QRhiSwapChain::setShadingRateMap(QRhiShadingRateMap *map)
Se asocia con el QRhiShadingRateMap map especificado. Esto solo funciona cuando se indica que la función QRhi::VariableRateShadingMap es compatible.
Cuando también se llama a ` QRhiCommandBuffer::setShadingRate()` (), se utiliza la tasa de sombreado más alta de las dos para cada mosaico. Actualmente no se ofrece ningún control sobre el comportamiento del combinador.
Nota: Establecer un mapa de tasas de sombreado implica que se necesita un nuevo QRhiRenderPassDescriptor diferente y que algunos de los objetos nativos de la cadena de intercambio deben reconstruirse. Por lo tanto, si la cadena de intercambio ya está configurada, llama a newCompatibleRenderPassDescriptor() y a setRenderPassDescriptor() inmediatamente después de setShadingRateMap(). A continuación, también debe volver a llamarse a createOrResize(). Esto tiene consecuencias en cadena, por ejemplo, para las tuberías gráficas: estas también deben asociarse al nuevo ` QRhiRenderPassDescriptor ` y, a continuación, recompilarse. Consulte ` QRhiRenderPassDescriptor::serializedFormat()` para obtener algunas sugerencias sobre cómo abordar esto. Recuerde establecer también el indicador ` QRhiGraphicsPipeline::UsesShadingRate ` para ellas.
Esta función se introdujo en Qt 6.9.
Véase también shadingRateMap().
void QRhiSwapChain::setWindow(QWindow *window)
Establece el valor de ` window`.
Véase también window().
[since 6.9] QRhiShadingRateMap *QRhiSwapChain::shadingRateMap() const
Devuelve el valor actualmente establecido de ` QRhiShadingRateMap`. Por defecto, este valor es ` nullptr`.
Esta función se introdujo en Qt 6.9.
Véase también setShadingRateMap().
[pure virtual] QSize QRhiSwapChain::surfacePixelSize()
Devuelve el tamaño de la superficie o capa asociada a la ventana.
Advertencia: Nose debe dar por sentado que esto es lo mismo que ` QWindow::size() * QWindow::devicePixelRatio()`. Con algunas API gráficas e interfaces de sistemas de ventanas (por ejemplo, Vulkan), existe la posibilidad teórica de que una superficie tenga un tamaño diferente al de la ventana asociada. Para dar soporte a estos casos, la lógica de renderizado debe basar siempre los cálculos derivados del tamaño (como, por ejemplo, las ventanas de visualización) en el tamaño proporcionado por ` QRhiSwapChain`, y nunca en el tamaño consultado mediante ` QWindow `.
Nota: También se puede llamar antes de ` createOrResize()`, siempre que al menos ` window()` ya esté establecido. Esto, en combinación con ` currentPixelSize()`, permite detectar cuándo es necesario redimensionar una cadena de intercambio. Sin embargo, hay que tener en cuenta que el tamaño del objeto nativo subyacente (superficie, capa o similar) es «dinámico», por lo que cada vez que se llama a esta función, devuelve el último valor comunicado por la implementación subyacente, sin garantía de atomicidad. Por lo tanto, se desaconseja encarecidamente utilizar esta función para determinar los tamaños de píxel de los recursos gráficos que se utilizan en un fotograma. En su lugar, utilice currentPixelSize(), que devuelve un tamaño atómico y que no cambiará entre las invocaciones de createOrResize().
Nota: Para los búferes de profundidad y estarcido utilizados en combinación con los búferes de color de la cadena de intercambio, se recomienda encarecidamente recurrir al comportamiento de dimensionamiento y reconstrucción automáticos que proporciona el indicador QRhiRenderBuffer:UsedWithSwapChainOnly. Evita consultar el tamaño de la superficie mediante esta función solo para obtener un tamaño que pueda pasarse a ` QRhiRenderBuffer::setPixelSize()` (), ya que ello adolecería de la falta de atomicidad descrita anteriormente.
Véase también ` currentPixelSize()`.
QWindow *QRhiSwapChain::window() const
Devuelve la ventana actualmente seleccionada.
Véase también setWindow().
© 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.