Qt 3D Gráfico de fotogramas de renderizado
El aspecto de renderizado de « Qt 3D » permite que el algoritmo de renderizado se base íntegramente en datos. La estructura de datos que lo controla se conoce como «framegraph». De forma similar a cómo el ECS (sistema de componentes de entidad) de Qt 3D permite definir lo que se conoce como «gráfico de escena» (Scenegraph) mediante la construcción de una escena a partir de un árbol de entidades y componentes, el «framegraph» también es una estructura de árbol, pero se utiliza con un propósito diferente. Concretamente, controla cómo se renderiza la escena.
A lo largo del renderizado de un solo fotograma, es probable que un renderizador 3D cambie de estado muchas veces. El número y la naturaleza de estos cambios de estado dependen no solo de los materiales (sombreadores, geometría de malla, texturas y variables uniformes) que se encuentren en la escena, sino también del esquema de renderizado de alto nivel que se esté utilizando.
Por ejemplo, utilizar un esquema de renderizado directo tradicional y sencillo es muy diferente a emplear un enfoque de renderizado diferido. Otras características, como los reflejos, las sombras, las múltiples ventanas de visualización y las pasadas tempranas de relleno Z, modifican los estados que un renderizador debe establecer a lo largo de un fotograma y el momento en que deben producirse dichos cambios de estado.
A modo de comparación, el renderizador de grafos de escena de «Qt Quick 2», responsable de dibujar las escenas de « Qt Quick 2», está programado de forma rígida en C++ para realizar tareas como el agrupamiento de primitivas y el renderizado de elementos opacos seguido del de elementos transparentes. En el caso de « Qt Quick 2», esto funciona perfectamente, ya que cubre todos los requisitos. Como se puede observar en algunos de los ejemplos mencionados anteriormente, es poco probable que un renderizador así, programado de forma rígida, sea lo suficientemente flexible para escenas 3D genéricas, dada la multitud de métodos de renderizado disponibles. O bien, si se pudiera crear un renderizador lo suficientemente flexible como para cubrir todos esos casos, es probable que su rendimiento se viera afectado por ser demasiado general. Para empeorar las cosas, se investigan constantemente nuevos métodos de renderizado. Por lo tanto, necesitábamos un enfoque que fuera a la vez flexible y extensible, pero que resultara sencillo de usar y mantener. ¡Aquí entra en juego el «framegraph»!
Cada nodo del «framegraph» define una parte de la configuración que el renderizador utilizará para renderizar la escena. La posición de un nodo en el árbol del «framegraph» determina cuándo y dónde el subárbol con raíz en ese nodo será la configuración activa en el proceso de renderizado. Como veremos más adelante, el renderizador recorre este árbol para construir el estado necesario para tu algoritmo de renderizado en cada punto del fotograma.
Obviamente, si solo quieres renderizar un cubo sencillo en pantalla, puede que pienses que esto es excesivo. Sin embargo, en cuanto quieras empezar a crear escenas un poco más complejas, esto te resultará muy útil. Para los casos más habituales, Qt 3D ofrece algunos ejemplos de framegraphs listos para usar tal cual.
Demostraremos la flexibilidad del concepto de «framegraph» presentando algunos ejemplos y los «framegraphs» resultantes.
Ten en cuenta que, a diferencia del «scenegraph», que se compone de entidades y componentes, el «framegraph» solo se compone de nodos anidados que son todos subclases de Qt3DRender::QFrameGraphNode. Esto se debe a que los nodos del «framegraph» no son objetos simulados en nuestro mundo virtual, sino más bien información de apoyo.
Pronto veremos cómo construir nuestro primer framegraph sencillo, pero antes de eso presentaremos los nodos de framegraph que tienes a tu disposición. Además, al igual que con el árbol del grafo de escena, las API de QML y C++ coinciden uno a uno, por lo que puedes optar por la que más te guste. En aras de la legibilidad y la concisión, para este artículo se ha elegido la API de QML.
La ventaja del framegraph es que, combinando estos tipos de nodos sencillos, es posible configurar el renderizador para que se adapte a tus necesidades específicas sin tener que tocar en absoluto ningún código de renderizado complejo y de bajo nivel en C/C++.
Reglas de FrameGraph
Para construir un árbol de framegraph que funcione correctamente, debes conocer algunas reglas sobre cómo se recorre y cómo pasarlo al renderizador Qt 3D.
Configuración del FrameGraph
El árbol FrameGraph debe asignarse a la propiedad `activeFrameGraph` de un componente `QRenderSettings`, que a su vez es un componente de la entidad raíz en la escena de Qt 3D. Esto es lo que lo convierte en el framegraph activo para el renderizador. Por supuesto, dado que se trata de un enlace de propiedad QML, el framegraph activo (o partes del mismo) se puede modificar sobre la marcha durante la ejecución. Por ejemplo, si deseas utilizar diferentes enfoques de renderizado para escenas de interior y exterior, o para activar o desactivar algún efecto especial.
Entity {
id: sceneRoot
components: RenderSettings {
activeFrameGraph: ... // FrameGraph tree
}
}Nota: «activeFrameGraph» es la propiedad predeterminada del componente FrameGraph en QML.
Entity {
id: sceneRoot
components: RenderSettings {
... // FrameGraph tree
}
}Cómo se utiliza el Framegraph
- El renderizador « Qt 3D » realiza un recorrido en profundidad del árbol del framegraph. Ten en cuenta que, dado que el recorrido es en profundidad, el orden en el que defines los nodos es importante.
- Cuando el renderizador llega a un nodo hoja del framegraph, recopila todo el estado especificado por la ruta desde el nodo hoja hasta el nodo raíz. Esto define el estado utilizado para renderizar una sección del fotograma. Si te interesa el funcionamiento interno de Qt 3D, esta recopilación de estado se denomina RenderView.
- A partir de la configuración contenida en una RenderView, el renderizador recopila todas las entidades del grafo de escena que deben renderizarse y, a partir de ellas, crea un conjunto de RenderCommands y los asocia a la RenderView.
- La combinación de RenderView y el conjunto de RenderCommands se pasa a OpenGL para su envío.
- Cuando esto se repite para cada nodo hoja del framegraph, el fotograma queda completo y el renderizador llama a QOpenGLContext::swapBuffers() para mostrarlo.
En esencia, el «framegraph» es un método basado en datos para configurar el renderizador Qt 3D. Gracias a su naturaleza basada en datos, podemos modificar la configuración en tiempo de ejecución, permitir que desarrolladores o diseñadores que no utilicen C++ cambien la estructura de un fotograma y probar nuevos enfoques de renderizado sin tener que escribir miles de líneas de código repetitivo.
Ejemplos de framegraph
Ahora que ya conoces las reglas que debes seguir al escribir un árbol de framegraph, vamos a repasar algunos ejemplos y analizarlos en detalle.
Un renderizador directo sencillo
El renderizado directo consiste en utilizar OpenGL de la forma tradicional y renderizar directamente en el backbuffer un objeto cada vez, sombreando cada uno de ellos sobre la marcha. Esto se contrapone al renderizado diferido, en el que se renderiza en un G-buffer intermedio. A continuación se muestra un FrameGraph sencillo que puede utilizarse para el renderizado directo:
Viewport {
normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
property alias camera: cameraSelector.camera
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
CameraSelector {
id: cameraSelector
}
}
}Como puedes ver, este árbol tiene una sola hoja y está compuesto por tres nodos en total, tal y como se muestra en el siguiente diagrama.

Siguiendo las reglas definidas anteriormente, este árbol FrameGraph genera una única RenderView con la siguiente configuración:
- Nodo hoja -> RenderView
- Ventana de visualización que ocupa toda la pantalla (utiliza coordenadas normalizadas para facilitar la compatibilidad con ventanas de visualización anidadas)
- Los búferes de color y profundidad están configurados para ser borrados
- Cámara especificada en la propiedad «camera» expuesta
Varios árboles FrameGraph diferentes pueden producir el mismo resultado de renderizado. Siempre que el estado recopilado desde la hoja hasta la raíz sea el mismo, el resultado también lo será. Es recomendable situar el estado que permanece constante durante más tiempo más cerca de la raíz del FrameGraph, ya que esto dará lugar a un menor número de nodos hoja y, por lo tanto, a un menor número de RenderViews en total.
Viewport {
normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
property alias camera: cameraSelector.camera
CameraSelector {
id: cameraSelector
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
}
}
}CameraSelector {
Viewport {
normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
}
}
}Un FrameGraph con múltiples ventanas de visualización
Pasemos ahora a un ejemplo ligeramente más complejo que renderiza un Scenegraph desde el punto de vista de cuatro cámaras virtuales en los cuatro cuadrantes de la ventana. Se trata de una configuración habitual en herramientas de CAD o modelado 3D, aunque podría adaptarse para renderizar, por ejemplo, un retrovisor en un juego de carreras de coches o la imagen de una cámara de CCTV.

Viewport {
id: mainViewport
normalizedRect: Qt.rect(0, 0, 1, 1)
property alias Camera: cameraSelectorTopLeftViewport.camera
property alias Camera: cameraSelectorTopRightViewport.camera
property alias Camera: cameraSelectorBottomLeftViewport.camera
property alias Camera: cameraSelectorBottomRightViewport.camera
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
}
Viewport {
id: topLeftViewport
normalizedRect: Qt.rect(0, 0, 0.5, 0.5)
CameraSelector { id: cameraSelectorTopLeftViewport }
}
Viewport {
id: topRightViewport
normalizedRect: Qt.rect(0.5, 0, 0.5, 0.5)
CameraSelector { id: cameraSelectorTopRightViewport }
}
Viewport {
id: bottomLeftViewport
normalizedRect: Qt.rect(0, 0.5, 0.5, 0.5)
CameraSelector { id: cameraSelectorBottomLeftViewport }
}
Viewport {
id: bottomRightViewport
normalizedRect: Qt.rect(0.5, 0.5, 0.5, 0.5)
CameraSelector { id: cameraSelectorBottomRightViewport }
}
}Este árbol es un poco más complejo, con cinco hojas. Siguiendo las mismas reglas que antes, construimos cinco objetos `RenderView` a partir del `FrameGraph`. Los siguientes diagramas muestran la construcción de las dos primeras `RenderViews`. Las `RenderViews` restantes son muy similares a las del segundo diagrama, solo que con los otros subárboles.


En total, los RenderViews creados son:
- RenderView (1)
- Ventana de visualización a pantalla completa definida
- Los búferes de color y profundidad están configurados para borrarse
- RenderView (2)
- Se ha definido una ventana de visualización a pantalla completa
- Se ha definido una ventana de visualización secundaria (la ventana de visualización de renderizado se escalará en relación con su ventana principal)
- Se ha especificado el selector de cámara
- RenderView (3)
- Ventana de visualización a pantalla completa definida
- Subventana de visualización definida (la ventana de renderizado se escalará en relación con su ventana principal)
- CameraSelector especificado
- RenderView (4)
- Ventana de visualización a pantalla completa definida
- Se ha definido una subventana de visualización (la ventana de visualización de renderizado se escalará en relación con su ventana principal)
- CameraSelector especificado
- RenderView (5)
- Ventana de visualización a pantalla completa definida
- Subventana de visualización definida (la ventana de visualización de renderizado se escalará en relación con la principal)
- CameraSelector especificado
Sin embargo, en este caso el orden es importante. Si el nodo ClearBuffers fuera el último en lugar del primero, esto daría lugar a una pantalla negra por la sencilla razón de que todo se borraría justo después de haber sido renderizado con tanto cuidado. Por una razón similar, no podría utilizarse como raíz del FrameGraph, ya que eso daría lugar a una llamada para borrar toda la pantalla en cada una de nuestras ventanas de visualización.
Aunque el orden de declaración del FrameGraph es importante, « Qt 3D » es capaz de procesar cada RenderView en paralelo, ya que cada RenderView es independiente de las demás a la hora de generar un conjunto de RenderCommands que se enviarán mientras el estado de la RenderView esté activo.
Qt 3D utiliza un enfoque del paralelismo basado en tareas que se escala de forma natural con el número de núcleos disponibles. Esto se muestra en el siguiente diagrama correspondiente al ejemplo anterior.

Los RenderCommands para las RenderViews se pueden generar en paralelo en muchos núcleos y, siempre que nos aseguremos de enviar las RenderViews en el orden correcto en el hilo de envío dedicado de OpenGL, la escena resultante se renderizará correctamente.
Renderizador diferido
En lo que respecta al renderizado, el renderizado diferido es un caso aparte en cuanto a la configuración del renderizador en comparación con el renderizado directo. En lugar de dibujar cada malla y aplicar un efecto de sombreador para sombrearla, el renderizado diferido adopta un método de dos pasadas de renderizado.
En primer lugar, todas las mallas de la escena se dibujan utilizando el mismo sombreador que generará, normalmente para cada fragmento, al menos cuatro valores:
- Vector normal del mundo
- Color (u otras propiedades del material)
- Profundidad
- Vector de posición mundial
Cada uno de estos valores se almacena en una textura. Las texturas de normal, color, profundidad y posición conforman lo que se denomina el G-Buffer. Durante la primera pasada no se dibuja nada en pantalla, sino que se dibuja en el G-Buffer para su uso posterior.
Una vez dibujadas todas las mallas, el G-Buffer se llena con todas las mallas que la cámara puede ver en ese momento. A continuación, la segunda pasada de renderizado se utiliza para renderizar la escena en el búfer de fondo con el sombreado de color final, leyendo los valores de normal, color y posición de las texturas del G-Buffer y generando un color en un cuadrante a pantalla completa.
La ventaja de esta técnica es que la gran potencia de cálculo necesaria para efectos complejos solo se utiliza durante la segunda pasada y únicamente en los elementos que la cámara está viendo realmente. La primera pasada no requiere mucha potencia de procesamiento, ya que cada malla se dibuja con un sombreador sencillo. Por lo tanto, el renderizado diferido desacopla el sombreado y la iluminación del número de objetos de una escena y, en su lugar, los acopla a la resolución de la pantalla (y del G-Buffer). Se trata de una técnica que se ha utilizado en muchos videojuegos debido a su capacidad para emplear un gran número de luces dinámicas, a costa de un mayor consumo de memoria de la GPU.
Viewport {
id: root
normalizedRect: Qt.rect(0.0, 0.0, 1.0, 1.0)
property GBuffer gBuffer
property alias camera: sceneCameraSelector.camera
property alias sceneLayer: sceneLayerFilter.layers
property alias screenQuadLayer: screenQuadLayerFilter.layers
RenderSurfaceSelector {
CameraSelector {
id: sceneCameraSelector
// Fill G-Buffer
LayerFilter {
id: sceneLayerFilter
RenderTargetSelector {
id: gBufferTargetSelector
target: gBuffer
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
RenderPassFilter {
id: geometryPass
matchAny: FilterKey {
name: "pass"
value: "geometry"
}
}
}
}
}
TechniqueFilter {
parameters: [
Parameter { name: "color"; value: gBuffer.color },
Parameter { name: "position"; value: gBuffer.position },
Parameter { name: "normal"; value: gBuffer.normal },
Parameter { name: "depth"; value: gBuffer.depth }
]
RenderStateSet {
// Render FullScreen Quad
renderStates: [
BlendEquation { blendFunction: BlendEquation.Add },
BlendEquationArguments {
sourceRgb: BlendEquationArguments.SourceAlpha
destinationRgb: BlendEquationArguments.DestinationColor
}
]
LayerFilter {
id: screenQuadLayerFilter
ClearBuffers {
buffers: ClearBuffers.ColorDepthBuffer
RenderPassFilter {
matchAny: FilterKey {
name: "pass"
value: "final"
}
parameters: Parameter {
name: "winSize"
value: Qt.size(1024, 768)
}
}
}
}
}
}
}
}
}(El código anterior está adaptado de qt3d/tests/manual/deferred-renderer-qml.)
Gráficamente, el «framegraph» resultante tiene este aspecto:

Y los RenderViews resultantes son:
- RenderView (1)
- Especificar qué cámara se debe utilizar
- Definir una ventana de visualización que ocupe toda la pantalla
- Seleccionar todas las entidades del componente de capa «sceneLayer»
- Establecer el «
gBuffer» como destino de renderizado activo - Borrar el color y la profundidad del destino de renderizado vinculado actualmente (el «
gBuffer») - Selecciona solo las entidades de la escena que tengan un material y una técnica que coincidan con las anotaciones del «RenderPassFilter»
- RenderView (2)
- Define una ventana de visualización que ocupe toda la pantalla
- Selecciona todas las entidades del componente de capa screenQuadLayer
- Borra los búferes de color y profundidad del búfer de fotogramas vinculado actualmente (la pantalla)
- Selecciona solo las entidades de la escena que tengan un material y una técnica que coincidan con las anotaciones del «RenderPassFilter»
Otras ventajas del framegraph
Dado que el árbol FrameGraph se basa íntegramente en datos y puede modificarse dinámicamente en tiempo de ejecución, puedes:
- Disponer de diferentes árboles de framegraph para distintas plataformas y hardware, y seleccionar el más adecuado en tiempo de ejecución
- Añadir y habilitar fácilmente la depuración visual en una escena
- Utilizar diferentes árboles FrameGraph en función de la naturaleza de lo que se necesite renderizar para una región concreta de la escena
- Implementar una nueva técnica de renderizado sin tener que modificar el funcionamiento interno de « Qt 3D »
Conclusión
Hemos presentado el FrameGraph y los tipos de nodos que lo componen. A continuación, hemos analizado algunos ejemplos para ilustrar las reglas de construcción del FrameGraph y cómo el motor de Qt 3D utiliza el FrameGraph entre bastidores. A estas alturas, ya deberías tener una visión general bastante clara del FrameGraph y de cómo se puede utilizar (quizás para añadir una pasada de relleno Z temprana a un renderizador directo). Además, debes tener siempre presente que el FrameGraph es una herramienta a tu disposición para que no te veas limitado al renderizador y a los materiales que Qt 3D proporciona de serie.
© 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.