Qt + OpenSceneGraph + OffScreen Rendering

Hoy vamos a ver como integrar OpenSceneGraph (a partir de ahora, OSG) con nuestra aplicación en Qt, pero no vamos a renderizar los frames directamente en pantalla, sino que utilizaremos una técnica llamada OffScreen Rendering. Esto es, renderizar la imagen directamente en un buffer o textura y luego transferir esta imagen resultante a otro lugar o mostrarla en pantalla.

Primero haremos un repaso de las herramientas a utilizar y porque:

• Qt: Para este ejemplo en particular he decidido utilizar el lenguaje C++, el lenguaje en el que está escrito el framework original, en primer lugar porque la gran mayoría de los motores gráficos están escritos en este lenguaje, y segundo por una cuestión de rendimiento.
  Para renderizar la escena utilisaremos el widget QGLWidget, el cual nos permite renderizar los frames sin necesidad de mostrar el widget (aunque también es posible mostrar el widget y renderizar directamente en pantalla, con casi nula modificación), los frames los obtendremos mediante el método QGLWidget::renderPixmap().
• OpenSceneGraph: OSG es un motor de gráficos 3D multiplataforma, utilizado para desarrollar videojuegos, programas de realidad virtual y aumentada, visualización científica y modelado 3D, entre otros usos que se le pueden dar. OSG está escrito en C++ estándar y usa OpenGL para renderizar la escena 3D.
  Las razones para elegirlo es por estar en una etapa de desarrollo considerada estable y en producción, por tener un gran numero de usuarios, y porque esta especialmente diseñado para usarse como motor de renderizado sin necesidad de depender de una interfaz gráfica en particular, se puede incluso renderizar una escena 3D directamente desde consola sin necesidad de lanzar ninguna ventana.
• OffScreen Rendering: Es la técnica por la cual es posible renderizar una escena 3D directamente en un buffer o textura sin pasar por pantalla.
  Algunos usos de esta técnica incluyen la generación de imágenes intermedias, renderizado por lotes de animaciones no interactivas, generación de imágenes de Alta resolución, etc, que cada uno saque sus propias conclusiones sobre el uso que podría darle al OffScreen Rendering.

Este tutorial es una pequeña modificación de algunos tutoriales que pueden encontrarse sobre OSG que pueden encontrarse navegando por la red.
Mi filosofía, como siempre lo ha sido, es mostrar solo el mínimo código necesario para levantar el entorno deseado. Aquí sólo mostraré como cargar un modelo 3D y como realizar una animación muy simple, sin interactuar con el usuario.
Comenzamos declarando la clase QOSGWidget la cual es derivada de QGLWidget. Esta sera la encargada de crear e inicializar el contexto OpenGL.

#include <QGLWidget>
#include <osgViewer/Viewer>
#include <osgDB/ReadFile>
#include <osgGA/TrackballManipulator>
#include <osg/MatrixTransform>

class QOSGWidget: public QGLWidget
{
    Q_OBJECT

    public:
        explicit QOSGWidget(QWidget *parent = 0);

    private:
        void initializeGL();
        void resizeGL(int width, int height);
        void paintGL();

    signals:

    public slots:

    private:
        float cow_rot;

        osg::ref_ptr<osgViewer::Viewer> viewer;
        osg::observer_ptr<osgViewer::GraphicsWindowEmbedded> window;
        osg::ref_ptr<osg::Node> loadedModel;
        osg::ref_ptr<osg::MatrixTransform> transformation;
};

Luego definimos sus metodos.

QOSGWidget::QOSGWidget(QWidget *parent): QGLWidget(parent)
{
    // Creamos un nuevo visor para mostrar la escena mediante OSG.
    viewer = new osgViewer::Viewer;

    // Creamos una matriz de transformación que luego usaremos para rotar el modelo 3D.
    // Esta, actuará como nodo raíz.
    transformation = new osg::MatrixTransform;

    // Cargamos el modelo 3D.
    // Este, actuará como Geodo (Nodo Geométrico o Nodo Hoja).
    loadedModel = osgDB::readNodeFile("data/cow.osg");

    // Establecemos al modelo 3D como descendiente de la transformación.
    transformation->addChild(loadedModel.get());

    // Angulo de rotación de 0°.
    cow_rot = 0;
}

void QOSGWidget::initializeGL()
{
    // Asociamos el contexto OpenGL creado por el QGLWidget a OSG
    // y configuramos el viewport.
    window = viewer->setUpViewerAsEmbeddedInWindow(0, 0, width(), height());

    // Asociamos algún método de manipulación de cámara para OSG.
    viewer->setCameraManipulator(new osgGA::TrackballManipulator);
}

void QOSGWidget::resizeGL(int width, int height)
{
    if (window.valid())
    {
        // Ajustamos las dimensiones de la escena OSG si el widget cambia de tamaño.
        window->resized(window->getTraits()->x, window->getTraits()->y, width, height);
        window->getEventQueue()->windowResize(window->getTraits()->x, window->getTraits()->y, width, height);
    }
}

void QOSGWidget::paintGL()
{
    // Establecemos una matriz de rotación para girar el modelo 3D
    // al rededor del eje vertical (eje z).
    transformation->setMatrix(osg::Matrix::rotate(cow_rot, 0, 0, 1));

    // Colocamos el nodo raíz adentro de la escena.
    viewer->setSceneData(transformation.get());

    // Aumentamos el angulo de rotación.
    cow_rot += 0.1;

    // Renderizamos el frame.
    if (viewer.valid())
        viewer->frame();
}

El código es tan simple y escueto que resulta realmente fácil de entender.
Aquí tienen el CF completo para ver la implementación.