Qt Quick Renderizador predeterminado del grafo de escena
Este documento explica cómo funciona internamente el renderizador predeterminado del grafo de escena, para que se pueda escribir código que lo utilice de forma óptima, tanto en términos de rendimiento como de funcionalidades.
No es necesario comprender el funcionamiento interno del renderizador para obtener un buen rendimiento. Sin embargo, puede resultar útil a la hora de integrarlo con el grafo de escena o para averiguar por qué no es posible sacar el máximo rendimiento al chip gráfico.
Nota: Incluso en el caso de que cada fotograma sea único y todo se cargue desde cero, el renderizador predeterminado funcionará correctamente.
Los elementos « Qt Quick » de una escena QML rellenan un árbol de instancias « QSGNode ». Una vez creado, este árbol constituye una descripción completa de cómo debe renderizarse un fotograma determinado. No contiene ninguna referencia a los elementos « Qt Quick » y, en la mayoría de las plataformas, se procesará y renderizará en un hilo independiente. El renderizador es una parte autónoma del grafo de escena que recorre el árbol QSGNode y utiliza la geometría definida en QSGGeometryNode y el estado del sombreador definido en QSGMaterial para actualizar el estado gráfico y generar llamadas de dibujo.
Si es necesario, el renderizador puede sustituirse por completo utilizando la API interna del back-end del grafo de escena. Esto resulta especialmente interesante para los proveedores de plataformas que deseen aprovechar las características de hardware no estándar. Para la mayoría de los casos de uso, el renderizador predeterminado será suficiente.
El renderizador predeterminado se centra en dos estrategias principales para optimizar el renderizado: el agrupamiento de llamadas de dibujo y la retención de geometría en la GPU.
Agrupación
Mientras que una API 2D tradicional, como QPainter, Cairo o Context2D, está diseñada para gestionar miles de llamadas de dibujo individuales por fotograma, OpenGL y otras API aceleradas por hardware rinden mejor cuando el número de llamadas de dibujo es muy bajo y los cambios de estado se reducen al mínimo.
Nota: Aunque en las siguientes secciones se utiliza OpenGL como ejemplo, los mismos conceptos se aplican también a otras API gráficas.
Consideremos el siguiente caso de uso:

La forma más sencilla de dibujar esta lista es celda por celda. En primer lugar, se dibuja el fondo, que es un rectángulo de un color específico. En términos de OpenGL, esto significa seleccionar un programa de sombreado para realizar rellenos de color sólido, configurar el color de relleno, establecer la matriz de transformación que contiene los desplazamientos x e y y, a continuación, utilizar, por ejemplo, glDrawArrays para dibujar los dos triángulos que forman el rectángulo. A continuación, se dibuja el icono. En términos de OpenGL, esto implica seleccionar un programa de sombreado para dibujar texturas, elegir la textura activa que se va a utilizar, configurar la matriz de transformación, habilitar la mezcla alfa y, a continuación, utilizar, por ejemplo, glDrawArrays para dibujar los dos triángulos que conforman el rectángulo delimitador del icono. El texto y la línea separadora entre celdas siguen un patrón similar. Y este proceso se repite para cada celda de la lista, por lo que, en el caso de una lista más larga, la sobrecarga impuesta por los cambios de estado de OpenGL y las llamadas de dibujo supera con creces la ventaja que podría aportar el uso de una API con aceleración por hardware.
Cuando cada primitiva es grande, esta sobrecarga es insignificante, pero en el caso de una interfaz de usuario típica, hay muchos elementos pequeños que, sumados, suponen una sobrecarga considerable.
El renderizador predeterminado del grafo de escena funciona dentro de estas limitaciones e intentará fusionar primitivas individuales en lotes, conservando exactamente el mismo resultado visual. El resultado es un menor número de cambios de estado de OpenGL y una cantidad mínima de llamadas de dibujo, lo que se traduce en un rendimiento óptimo.
Primitivas opacas
El renderizador distingue entre primitivas opacas y primitivas que requieren mezcla alfa. Al utilizar el búfer Z de OpenGL y asignar a cada primitiva una posición Z única, el renderizador puede reordenar libremente las primitivas opacas sin tener en cuenta su ubicación en pantalla ni con qué otros elementos se superponen. Al analizar el estado del material de cada primitiva, el renderizador creará lotes opacos. A partir de un conjunto básico de elementos de Qt Quick, esto incluye elementos Rectangle con colores opacos e imágenes totalmente opacas, como JPEG o BMP.
Otra ventaja de utilizar primitivas opacas es que no requieren que esté activado el modo « GL_BLEND », lo cual puede resultar bastante costoso, especialmente en GPU móviles e integradas.
Las primitivas opacas se renderizan de delante hacia atrás con las opciones « glDepthMask » y « GL_DEPTH_TEST » activadas. En las GPU que realizan internamente comprobaciones de z tempranas, esto significa que el sombreador de fragmentos no necesita ejecutarse para los píxeles o bloques de píxeles que están ocultos. Ten en cuenta que el renderizador sigue teniendo que tener en cuenta estos nodos y que el sombreador de vértices se sigue ejecutando para cada vértice de estas primitivas, por lo que, si la aplicación sabe que algo está completamente oculto, lo mejor es ocultarlo explícitamente utilizando Item::visible o Item::opacity.
Nota: El « Item::z » se utiliza para controlar el orden de superposición de un elemento (Item) respecto a sus hermanos. No tiene relación directa con el renderizador ni con el búfer Z de OpenGL.
Primitivas con mezcla alfa
Una vez dibujadas las primitivas opacas, el renderizador desactivará la opción « glDepthMask », activará la opción « GL_BLEND » y renderizará todas las primitivas con mezcla alfa de atrás hacia delante.
El procesamiento por lotes de las primitivas con mezcla alfa requiere un poco más de esfuerzo por parte del renderizador, ya que los elementos que se superponen deben renderizarse en el orden correcto para que la mezcla alfa se vea bien. No basta con basarse únicamente en el búfer Z. El renderizador realiza una pasada por todas las primitivas con mezcla alfa y analiza su rectángulo delimitador, además de su estado de material, para determinar qué elementos pueden agruparse y cuáles no.

En el caso más a la izquierda, los fondos azules se pueden dibujar en una sola llamada y los dos elementos de texto en otra, ya que los textos solo se superponen a un fondo que tienen delante. En el caso situado más a la derecha, el fondo del «Elemento 4» se superpone al texto del «Elemento 3», por lo que, en este caso, tanto los fondos como los textos deben dibujarse mediante llamadas separadas.
En cuanto al eje Z, las primitivas alfa se intercalan con los nodos opacos y pueden activar el «early-z» cuando esté disponible, pero, de nuevo, establecer ` Item::visible ` en `false` siempre es más rápido.
Combinación con primitivas 3D
El grafo de escena admite primitivas pseudo-3D y primitivas 3D propiamente dichas. Por ejemplo, se puede implementar un efecto de «página doblada» utilizando ` ShaderEffect ` o implementar un toro con mapa de relieve utilizando ` QSGGeometry ` y un material personalizado. Al hacerlo, hay que tener en cuenta que el renderizador por defecto ya utiliza el búfer de profundidad.
El renderizador modifica el sombreador de vértices devuelto por QSGMaterialShader::vertexShader() y comprime los valores z del vértice una vez aplicadas las matrices de modelo-vista y de proyección; a continuación, añade una pequeña traslación en el eje z para situarlo en la posición z correcta.
La compresión parte de la base de que los valores z se encuentran en el intervalo de 0 a 1.
Atlas de texturas
La textura activa es un estado único de OpenGL, lo que significa que no se pueden agrupar en lotes varias primitivas que utilicen texturas de OpenGL diferentes. Por este motivo, el grafo de escena de Qt Quick permite asignar varias instancias de QSGTexture como subregiones más pequeñas de una textura más grande: un atlas de texturas.
La mayor ventaja de los atlas de texturas es que varias instancias de ` QSGTexture ` hacen referencia ahora a la misma instancia de textura de OpenGL. Esto permite agrupar también las llamadas de dibujo con textura, como los elementos `Image`, ` BorderImage `, ` ShaderEffect `, así como tipos de C++ como ` QSGSimpleTextureNode ` y los `QSGGeometryNodes` personalizados que utilizan texturas.
Nota: Las texturasde gran tamaño no se incluyen en el atlas de texturas.
Las texturas basadas en atlas se crean pasando QQuickWindow::TextureCanUseAtlas a la función QQuickWindow::createTextureFromImage().
Nota: Las texturas basadasen atlas no tienen coordenadas de textura que oscilen entre 0 y 1. Utiliza QSGTexture::normalizedTextureSubRect() para obtener las coordenadas de textura del atlas.
El grafo de escena utiliza heurísticas para determinar el tamaño que debe tener el atlas y cuál es el umbral de tamaño para que una textura se incluya en él. Si se necesitan valores diferentes, es posible sobrescribirlos utilizando las variables de entorno QSG_ATLAS_WIDTH=[width], QSG_ATLAS_HEIGHT=[height] y QSG_ATLAS_SIZE_LIMIT=[size]. Modificar estos valores resultará de interés principalmente para los proveedores de plataformas.
Raíces de lotes
Además de agrupar primitivas compatibles en lotes, el renderizador predeterminado también intenta minimizar la cantidad de datos que hay que enviar a la GPU en cada fotograma. El renderizador predeterminado identifica los subárboles que pertenecen a un mismo conjunto e intenta agruparlos en lotes separados. Una vez identificados los lotes, se fusionan, se cargan y se almacenan en la memoria de la GPU mediante objetos de búfer de vértices.
Nodos de transformación
Cada elemento « Qt Quick » inserta un « QSGTransformNode » en el árbol del gráfico de escena para gestionar sus coordenadas x, y, escala o rotación. Los elementos hijos se colocarán bajo este nodo de transformación. El renderizador predeterminado realiza un seguimiento del estado de los nodos de transformación entre fotogramas y examina los subárboles para decidir si un nodo de transformación es un buen candidato para convertirse en raíz de un conjunto de lotes. Un nodo de transformación que cambia entre fotogramas y que tiene un subárbol bastante complejo puede convertirse en raíz de un lote.
Los QSGGeometryNodes del subárbol de una raíz de lote se transforman previamente en relación con la raíz en la CPU. A continuación, se cargan y se conservan en la GPU. Cuando cambia la transformación, el renderizador solo tiene que actualizar la matriz de la raíz, no cada elemento individual, lo que hace que el desplazamiento por listas y cuadrículas sea muy rápido. Para los fotogramas sucesivos, siempre que no se añadan ni se eliminen nodos, el renderizado de la lista es, a efectos prácticos, gratuito. Cuando entra contenido nuevo en el subárbol, se reconstruye el lote que lo contiene, pero esto sigue siendo relativamente rápido. Normalmente hay varios fotogramas que no cambian por cada fotograma en el que se añaden o eliminan nodos al desplazarse por una cuadrícula o una lista.
Otra ventaja de identificar los nodos de transformación como raíces de lote es que permite al renderizador conservar las partes del árbol que no han cambiado. Por ejemplo, supongamos que una interfaz de usuario consta de una lista y una fila de botones. Cuando se desplaza la lista y se añaden o eliminan delegados, el resto de la interfaz de usuario, la fila de botones, permanece inalterada y puede dibujarse utilizando la geometría ya almacenada en la GPU.
El umbral de nodos y vértices para que un nodo de transformación se convierta en una raíz de lote se puede anular mediante las variables de entorno QSG_RENDERER_BATCH_NODE_THRESHOLD=[count] y QSG_RENDERER_BATCH_VERTEX_THRESHOLD=[count]. Anular estos indicadores resultará especialmente útil para los proveedores de plataformas.
Nota: Bajo una raíz de lote, se crea un lote por cada conjunto único de estado de material y tipo de geometría.
Recorte
Al establecer Item::clip en «true», se creará un QSGClipNode con un rectángulo en su geometría. El renderizador predeterminado aplicará este recorte utilizando el método «scissoring» en OpenGL. Si el elemento se gira en un ángulo distinto de 90 grados, se utiliza el búfer de estarcido de OpenGL. Qt Quick El elemento solo admite la configuración de un rectángulo como recorte a través de QML, pero la API del grafo de escena y el renderizador predeterminado pueden utilizar cualquier forma para el recorte.
Al aplicar un recorte a un subárbol, dicho subárbol debe renderizarse con un estado de OpenGL único. Esto significa que, cuando ` Item::clip ` es verdadero, el procesamiento por lotes de ese elemento se limita a sus hijos. Cuando hay muchos hijos, como en el caso de ` ListView ` o ` GridView`, o hijos complejos, como en el caso de ` TextArea`, esto no supone ningún problema. Sin embargo, hay que utilizar «clip» con precaución en elementos más pequeños, ya que impide el procesamiento por lotes. Esto incluye etiquetas de botones, campos de texto o delegados de lista y celdas de tabla. A menudo se puede evitar recortar un «Flickable» (o vista de elemento) organizando la interfaz de usuario de modo que los elementos opacos cubran las áreas alrededor del «Flickable» y, en caso contrario, recurriendo a los bordes de la ventana para recortar todo lo demás.
Al establecer ` Item::clip ` en ` true `, también se activa el indicador ` QQuickItem::ItemIsViewport `; los elementos secundarios con el indicador ` QQuickItem::ItemObservesViewport ` pueden utilizar el área de visualización para un paso aproximado de recorte previo: por ejemplo, ` Text ` omite las líneas de texto que se encuentran completamente fuera del área de visualización. Omitir nodos del grafo de escena o limitar el ` vertices ` es una optimización que se puede lograr estableciendo ` flags ` en C++ en lugar de establecer ` Item::clip ` en QML.
Al implementar ` QQuickItem::updatePaintNode()` en un elemento personalizado, si este puede renderizar muchos detalles en una gran área geométrica, debes plantearte si resulta eficiente limitar los gráficos a la ventana de visualización; en tal caso, puedes establecer el indicador ` ItemObservesViewport ` y leer el área expuesta actualmente mediante ` QQuickItem::clipRect()`. Una consecuencia de ello es que se llamará a `updatePaintNode()` con mayor frecuencia (normalmente una vez por fotograma cada vez que el contenido se mueva en el área de visualización).
Búferes de vértices
Cada lote utiliza un objeto de búfer de vértices (VBO) para almacenar sus datos en la GPU. Este búfer de vértices se conserva entre fotogramas y se actualiza cuando cambia la parte del grafo de escena que representa.
Por defecto, el renderizador cargará los datos en el VBO utilizando GL_STATIC_DRAW. Es posible seleccionar una estrategia de carga diferente configurando la variable de entorno QSG_RENDERER_BUFFER_STRATEGY=[strategy]. Los valores válidos son stream y dynamic. Cambiar este valor resulta útil principalmente para los proveedores de plataformas.
Suavizado
El grafo de escena admite dos tipos de suavizado. Por defecto, las primitivas, como los rectángulos y las imágenes, se suavizan añadiendo más vértices a lo largo de sus bordes, de modo que estos se difuminan hasta volverse transparentes. A este método lo denominamos suavizado por vértices. Si el usuario solicita un contexto OpenGL con multimuestreo, configurando ` QSurfaceFormat ` con un número de muestras superior a ` 0 ` mediante ` QQuickWindow::setFormat()`, el grafo de escena dará prioridad al suavizado basado en multimuestreo (MSAA). Ambas técnicas influyen en cómo se lleva a cabo el renderizado internamente y presentan diferentes limitaciones.
También es posible anular el método de suavizado utilizado estableciendo la variable de entorno QSG_ANTIALIASING_METHOD en vertex o msaa.
El suavizado de vértices puede producir líneas de unión entre los bordes de primitivas adyacentes, incluso cuando ambos bordes sean matemáticamente idénticos. El suavizado por multimuestreo no las produce.
Suavizado de vértices
El suavizado de vértices se puede activar y desactivar para cada elemento mediante la propiedad Item::antialiasing. Funcionará independientemente de lo que admita el hardware subyacente y produce un suavizado de mayor calidad, tanto para primitivas renderizadas normalmente como para primitivas capturadas en objetos de búfer de fotogramas, por ejemplo, utilizando el tipo ShaderEffectSource.
La desventaja de utilizar el suavizado de vértices es que cada primitiva con el suavizado activado tendrá que ser mezclada. En cuanto al procesamiento por lotes, esto significa que el renderizador tiene que realizar más trabajo para determinar si la primitiva puede procesarse por lotes o no y, debido a los solapamientos con otros elementos de la escena, también puede dar lugar a un menor número de lotes, lo que podría afectar al rendimiento.
En hardware de gama baja, la mezcla también puede resultar bastante costosa, por lo que, en el caso de una imagen o un rectángulo redondeado que cubra la mayor parte de la pantalla, la cantidad de mezcla necesaria para el interior de estas primitivas puede provocar una pérdida significativa de rendimiento, ya que hay que mezclar la primitiva completa.
Antialiasing multimuestra
El antialiasing multimuestra es una característica del hardware mediante la cual este calcula un valor de cobertura por píxel en la primitiva. Algunos equipos pueden realizar el antialiasing multimuestra a un coste muy bajo, mientras que otros pueden necesitar tanto más memoria como más ciclos de la GPU para renderizar un fotograma.
Mediante el antialiasing multimuestra, muchas primitivas, como los rectángulos redondeados y los elementos de imagen, pueden someterse a antialiasing y seguir siendo opacas en el grafo de escena. Esto significa que el renderizador tiene más facilidad a la hora de crear lotes y puede recurrir al early-z para evitar el sobredibujo.
Cuando se utiliza el antialiasing de multimuestreo, el contenido renderizado en objetos de búfer de fotogramas necesita extensiones adicionales para admitir el multimuestreo de los búferes de fotogramas. Normalmente, GL_EXT_framebuffer_multisample y GL_EXT_framebuffer_blit. La mayoría de los chips de escritorio cuentan con estas extensiones, pero son menos habituales en los chips integrados. Cuando el multimuestreo de framebuffer no está disponible en el hardware, el contenido renderizado en objetos de framebuffer no se suavizará, incluido el contenido de un ShaderEffectSource.
Rendimiento
Como se ha indicado al principio, no es necesario comprender los detalles más sutiles del renderizador para obtener un buen rendimiento. Está diseñado para optimizarse en los casos de uso habituales y funcionará bastante bien en casi cualquier circunstancia.
- Un buen rendimiento se consigue mediante un procesamiento por lotes eficaz, en el que se vuelva a cargar la menor cantidad posible de geometría una y otra vez. Al establecer la variable de entorno
QSG_RENDERER_DEBUG=render, el renderizador mostrará estadísticas sobre el rendimiento del procesamiento por lotes, cuántos lotes se utilizan, qué lotes se conservan y cuáles son opacos y cuáles no. Cuando se busque un rendimiento óptimo, las cargas solo deben realizarse cuando sea realmente necesario; los lotes deben ser menos de 10 y al menos 3 o 4 de ellos deben ser opacos. - El renderizador predeterminado no realiza ningún recorte de la ventana gráfica ni detección de oclusión por parte de la CPU. Si se supone que algo no debe ser visible, no debe mostrarse. Utiliza `
Item::visible: false` para los elementos que no deban dibujarse. La razón principal para no añadir dicha lógica es que supone un coste adicional que también perjudicaría a las aplicaciones que se han esforzado por comportarse correctamente. - Asegúrate de utilizar el atlas de texturas. Los elementos «Image» y « BorderImage » lo utilizarán a menos que la imagen sea demasiado grande. Para las texturas creadas en C++, pasa ` QQuickWindow::TextureCanUseAtlas ` al llamar a `QQuickWindow::createTexture()`. Al establecer la variable de entorno `
QSG_ATLAS_OVERLAY`, todas las texturas del atlas se colorearán para que sean fácilmente identificables en la aplicación. - Utiliza primitivas opacas siempre que sea posible. Las primitivas opacas se procesan más rápido en el renderizador y se dibujan más rápido en la GPU. Por ejemplo, los archivos PNG suelen tener un canal alfa, aunque cada píxel sea totalmente opaco. Los archivos JPG son siempre opacos. Al proporcionar imágenes a un ` QQuickImageProvider ` o al crear imágenes con ` QQuickWindow::createTextureFromImage()` (), haz que la imagen tenga ` QImage::Format_RGB32`, siempre que sea posible.
- Ten en cuenta que los elementos compuestos que se superponen, como en la ilustración anterior, no se pueden procesar por lotes.
- El recorte interrumpe el procesamiento por lotes. Nunca lo utilices por elementos individuales, dentro de celdas de tabla, delegados de elementos o similares. En lugar de recortar texto, utiliza la elisión. En lugar de recortar una imagen, crea un ` QQuickImageProvider ` que devuelva una imagen recortada.
- El procesamiento por lotes solo funciona con índices de 16 bits. Todos los elementos integrados utilizan índices de 16 bits, pero una geometría personalizada también puede utilizar índices de 32 bits.
- Algunos indicadores de material impiden el procesamiento por lotes; el más restrictivo es « QSGMaterial::RequiresFullMatrix », que impide cualquier tipo de procesamiento por lotes.
- Las aplicaciones con fondo monocromo deben configurarlo mediante ` QQuickWindow::setColor()` en lugar de utilizar un elemento `Rectangle` de nivel superior. ` QQuickWindow::setColor()` se utilizará en una llamada a `
glClear()`, lo cual puede resultar más rápido. - Los elementos de imagen con mipmaps no se colocan en el atlas global y no se agruparán.
- Un error en el controlador de OpenGL relacionado con las lecturas de objetos de búfer de fotogramas (FBO) puede corromper los glifos renderizados. Si se establece la variable de entorno
QML_USE_GLYPHCACHE_WORKAROUND, Qt mantiene una copia adicional del glifo en la RAM. Esto significa que el rendimiento es ligeramente inferior al dibujar glifos que no se han dibujado antes, ya que Qt accede a la copia adicional a través de la CPU. También significa que la caché de glifos utilizará el doble de memoria. La calidad no se ve afectada por ello.
Si una aplicación tiene un rendimiento deficiente, asegúrate de que el renderizado sea realmente el cuello de botella. ¡Utiliza un perfilador! La variable de entorno QSG_RENDER_TIMING=1 mostrará una serie de parámetros de tiempo útiles que pueden servir para identificar dónde se encuentra el problema.
Grupos de mutabilidad
A veces, el análisis revelará que el renderizador agrupa contenido que se actualiza regularmente junto con contenido estático. En tales casos, será mejor dividir la geometría en dos lotes separados en lugar de cargar un lote más grande de contenido prácticamente inalterado en cada actualización.
Veamos el siguiente ejemplo:
Column {
Timer {
interval: 1000
running: true
repeat: true
onTriggered: dynamicText.counter++
}
Text {
id: dynamicText
property int counter: 0
text: counter
mutabilityGroup: Item.DynamicMutabilityGroup
}
Text {
id: staticText1
text: "Static label"
}
Text {
id: staticText2
text: "Static label"
}
}Esta aplicación consta de una etiqueta « dynamicText » que se actualiza cada segundo. Además, cuenta con dos etiquetas de texto estáticas que nunca se actualizan.
Si en este ejemplo no se estableciera ningún grupo de mutabilidad explícito, la geometría de las etiquetas de texto estáticas se agruparía junto con la etiqueta dinámica. Esto se debe a que todas utilizan el mismo material y las mismas propiedades básicas, y el renderizador por lotes del grafo de escena intentará minimizar el número de llamadas de dibujo necesarias para mostrar todo el texto de la escena (hasta un límite determinado). Como resultado, los 88 vértices que representan el texto estático de la escena se volverán a cargar cada vez que cambie el texto dinámico.
Al establecer el «mutabilityGroup» de la etiqueta « dynamicText » en « Item.DynamicMutabilityGroup », indicamos al renderizador que la etiqueta se actualizará con frecuencia. De este modo, nunca se agrupará con el resto del contenido, que pertenece al grupo de mutabilidad predeterminado. Si hay varios elementos que se actualizan al mismo ritmo, aún así se pueden agrupar asignándolos al mismo grupo.
Hay un total de 16 grupos de mutabilidad disponibles, incluido el grupo predeterminado 0.
Para la gran mayoría de los elementos de la interfaz de usuario, se debe utilizar el grupo de mutabilidad predeterminado. Solo se debe anular en casos en los que el análisis revele un cuello de botella causado por la recarga de geometrías estáticas de gran tamaño.
Visualización
Para visualizar los distintos aspectos del renderizador predeterminado del grafo de escena, la variable de entorno QSG_VISUALIZE puede configurarse con uno de los valores detallados en cada una de las secciones siguientes. A continuación, ofrecemos ejemplos de la salida de algunas de las variables utilizando el siguiente código QML:
import QtQuick 2.2
Rectangle {
width: 200
height: 140
ListView {
id: clippedList
x: 20
y: 20
width: 70
height: 100
clip: true
model: ["Item A", "Item B", "Item C", "Item D"]
delegate: Rectangle {
color: "lightblue"
width: parent.width
height: 25
Text {
text: modelData
anchors.fill: parent
horizontalAlignment: Text.AlignHCenter
verticalAlignment: Text.AlignVCenter
}
}
}
ListView {
id: clippedDelegateList
x: clippedList.x + clippedList.width + 20
y: 20
width: 70
height: 100
clip: true
model: ["Item A", "Item B", "Item C", "Item D"]
delegate: Rectangle {
color: "lightblue"
width: parent.width
height: 25
clip: true
Text {
text: modelData
anchors.fill: parent
horizontalAlignment: Text.AlignHCenter
verticalAlignment: Text.AlignVCenter
}
}
}
}Para el « ListView » de la izquierda, establecemos su propiedad « clip » en « true ». Para el « ListView » de la derecha, también establecemos la propiedad « clip » de cada delegado en « true » para ilustrar los efectos del recorte en el procesamiento por lotes.

Original
Nota: Los elementos visualizados no respetan el recorte, y el orden de representación es arbitrario.
Visualización de lotes
Al establecer ` QSG_VISUALIZE ` en ` batches `, se visualizan los lotes en el renderizador. Los lotes fusionados se dibujan con un color liso y los no fusionados, con un patrón de líneas diagonales. Un número reducido de colores distintos indica una buena agrupación en lotes. Los lotes no fusionados son problemáticos si contienen muchos nodos individuales.

QSG_VISUALIZE=batches
Visualización del recorte
Al establecer « QSG_VISUALIZE » en « clip », se dibujan áreas rojas sobre la escena para indicar el recorte. Dado que los elementos de « Qt Quick » no se recortan por defecto, normalmente no se visualiza ningún recorte.

QSG_VISUALIZE=clip
Visualización de cambios
Al establecer « QSG_VISUALIZE » en « changes », se visualizan los cambios en el renderizador. Los cambios en el grafo de escena se visualizan con una superposición parpadeante de un color aleatorio. Los cambios en una primitiva se visualizan con un color sólido, mientras que los cambios en un antepasado, como los cambios de matriz u opacidad, se visualizan con un patrón.
Visualización del sobredibujado
Al establecer QSG_VISUALIZE en overdraw se visualiza el sobredibujado en el renderizador. Visualiza todos los elementos en 3D para resaltar los sobredibujados. Este modo también se puede utilizar para detectar, hasta cierto punto, geometría fuera de la ventana gráfica. Los elementos opacos se renderizan con un tinte verde, mientras que los elementos translúcidos se renderizan con un tinte rojo. El rectángulo delimitador de la ventana gráfica se representa en azul. El contenido opaco es más fácil de procesar para el grafo de escena y, por lo general, se renderiza más rápido.
Ten en cuenta que el rectángulo raíz del código anterior es superfluo, ya que la ventana también es blanca, por lo que dibujar el rectángulo supone un desperdicio de recursos en este caso. Cambiarlo por un elemento (Item) puede suponer una ligera mejora en el rendimiento.


QSG_VISUALIZE=overdraw
Representación a través de la interfaz de hardware de representación de Qt
A partir de Qt 6.0, la adaptación por defecto siempre se realiza a través de una capa de abstracción gráfica, la Interfaz de Hardware de Representación de Qt (RHI), proporcionada por el Qt GUI módulo. Esto significa que, a diferencia de Qt 5, el grafo de escena no realiza llamadas directas a OpenGL. En su lugar, registra los comandos de recursos y de dibujo utilizando las API de la RHI, que a su vez traducen el flujo de comandos en llamadas a OpenGL, Vulkan, Metal o Direct 3D. La gestión de los shaders también se unifica escribiendo el código del shader una sola vez, compilándolo a SPIR-V y, a continuación, traduciéndolo al lenguaje adecuado para las distintas API gráficas.
Para controlar el comportamiento, se pueden utilizar las siguientes variables de entorno:
| Variable de entorno | Valores posibles | Descripción |
|---|---|---|
QSG_RHI_BACKEND | vulkan, metal, opengl, d3d11, d3d12 | Solicita el backend específico de RHI. Por defecto, la API gráfica se elige en función de la plataforma, a menos que se anule mediante esta variable o las API equivalentes de C++. Los valores por defecto actuales son Direct3D 11 para Windows, Metal para macOS y OpenGL para el resto de plataformas. |
QSG_INFO | 1 | Al igual que con la ruta de renderizado basada en OpenGL, al establecer esta opción se habilita la impresión de información del sistema al inicializar el grafo de escena de Qt Quick. Esto puede resultar muy útil para la resolución de problemas. |
QSG_RHI_DEBUG_LAYER | 1 | Cuando sea aplicable (Vulkan, Direct3D), habilita las capas de depuración o validación de la implementación de la API gráfica, si están disponibles, ya sea en el dispositivo gráfico o en el objeto de instancia. Para Metal en macOS, configura en su lugar la variable de entorno ` METAL_DEVICE_WRAPPER_TYPE=1 `. |
QSG_RHI_PREFER_SOFTWARE_RENDERER | 1 | Solicita que se elija un adaptador o dispositivo físico que utilice rasterización basada en software. Solo es aplicable cuando la API subyacente admite la enumeración de adaptadores (por ejemplo, Direct3D o Vulkan); en caso contrario, se ignora. |
Las aplicaciones que deseen ejecutarse siempre con una única API gráfica determinada también pueden solicitarlo mediante C++. Por ejemplo, la siguiente llamada realizada al principio de main(), antes de construir cualquier QQuickWindow, fuerza el uso de Vulkan (y, de lo contrario, dará error):
QQuickWindow::setGraphicsApi(QSGRendererInterface::Vulkan);Véase QSGRendererInterface::GraphicsApi. Los valores de la enumeración OpenGL, Vulkan, Metal, Direct3D11 y Direct3D12 tienen el mismo efecto que ejecutar con QSG_RHI_BACKEND establecido en la clave de cadena equivalente.
Todos los backends de QRhi elegirán el adaptador de GPU o el dispositivo físico predeterminado del sistema, a menos que se anule mediante QSG_RHI_PREFER_SOFTWARE_RENDERER o una variable específica del backend, como QT_D3D_ADAPTER_INDEX o QT_VK_PHYSICAL_DEVICE_INDEX. Por el momento, no se ofrece ninguna otra opción de configuración del adaptador.
A partir de Qt 6.5, algunos de los ajustes que antes solo estaban disponibles como variables de entorno están ahora disponibles como API de C++ en QQuickGraphicsConfiguration. Por ejemplo, establecer ` QSG_RHI_DEBUG_LAYER ` y llamar a ` setDebugLayer` (true) son equivalentes.
© 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.