Ejemplo de ventana OpenGL
Este ejemplo muestra cómo crear una aplicación mínima basada en QWindow con el fin de utilizar OpenGL.

Nota: Este es un ejemplo de bajo nivel sobre cómo utilizar QWindow con OpenGL. En la práctica, deberías plantearte utilizar la clase de nivel superior QOpenGLWindow. Consulta el ejemplo «Hello GLES3» para ver una demostración de la clase de conveniencia QOpenGLWindow.
Superclase OpenGLWindow
Nuestra clase `OpenGLWindow` actúa como una API de la que se derivan subclases para realizar el renderizado propiamente dicho. Dispone de funciones para solicitar que se llame a `render()`, ya sea de forma inmediata con `renderNow()` o tan pronto como el bucle de eventos haya terminado de procesar el lote actual de eventos con `renderLater()`. La subclase de OpenGLWindow puede reimplementar render() para el renderizado basado en OpenGL, o render(QPainter *) para el renderizado con un QPainter. Utiliza OpenGLWindow::setAnimating(true) para que se llame a render() a la frecuencia de refresco vertical, siempre que la sincronización vertical esté habilitada en los controladores OpenGL subyacentes.
En la clase que realiza el renderizado OpenGL, lo habitual es heredar de ` QOpenGLFunctions`, tal y como hace nuestra `OpenGLWindow`, con el fin de obtener un acceso independiente de la plataforma a las funciones de OpenGL ES 2.0. Al heredar de ` QOpenGLFunctions `, las funciones de OpenGL que contiene tendrán prioridad, y no tendrás que preocuparte por resolver esas funciones si quieres que tu aplicación funcione tanto con OpenGL como con OpenGL ES 2.0.
class OpenGLWindow : public QWindow, protected QOpenGLFunctions
{
Q_OBJECT
public:
explicit OpenGLWindow(QWindow *parent = nullptr);
~OpenGLWindow();
virtual void render(QPainter *painter);
virtual void render();
virtual void initialize();
void setAnimating(bool animating);
public slots:
void renderLater();
void renderNow();
protected:
bool event(QEvent *event) override;
void exposeEvent(QExposeEvent *event) override;
private:
bool m_animating = false;
QOpenGLContext *m_context = nullptr;
QOpenGLPaintDevice *m_device = nullptr;
};El tipo de superficie de la ventana debe establecerse en « QSurface::OpenGLSurface » para indicar que la ventana se va a utilizar para el renderizado OpenGL y no para renderizar contenido ráster con « QPainter » utilizando un « QBackingStore ».
OpenGLWindow::OpenGLWindow(QWindow *parent)
: QWindow(parent)
{
setSurfaceType(QWindow::OpenGLSurface);
}Cualquier inicialización de OpenGL necesaria puede realizarse sobrescribiendo la función initialize(), que se invoca una vez antes de la primera llamada a render(), con un QOpenGLContext válido. Como se puede observar en el siguiente fragmento de código, las implementaciones predeterminadas de render(QPainter *) e initialize() están vacías, mientras que la implementación predeterminada de render() inicializa un QOpenGLPaintDevice y, a continuación, llama a render(QPainter *).
void OpenGLWindow::render(QPainter *painter)
{
Q_UNUSED(painter);
}
void OpenGLWindow::initialize()
{
}
void OpenGLWindow::render()
{
if (!m_device)
m_device = new QOpenGLPaintDevice;
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT | GL_STENCIL_BUFFER_BIT);
m_device->setSize(size() * devicePixelRatio());
m_device->setDevicePixelRatio(devicePixelRatio());
QPainter painter(m_device);
render(&painter);
}La función `renderLater()` simplemente llama a ` QWindow::requestUpdate()` para programar una actualización para cuando el sistema esté listo para volver a dibujar.
También llamamos a `renderNow()` cuando recibimos un evento `expose`. El evento `exposeEvent()` es la notificación a la ventana de que su exposición —es decir, su visibilidad— en la pantalla ha cambiado. Cuando se recibe el evento `expose`, puedes consultar ` QWindow::isExposed()` para averiguar si la ventana está expuesta en ese momento o no. No realices el renderizado ni llames a ` QOpenGLContext::swapBuffers()` en una ventana antes de que haya recibido su primer evento «expose», ya que, hasta entonces, su tamaño final podría ser desconocido y, además, lo que se renderice podría ni siquiera llegar a aparecer en la pantalla.
void OpenGLWindow::renderLater()
{
requestUpdate();
}
bool OpenGLWindow::event(QEvent *event)
{
switch (event->type()) {
case QEvent::UpdateRequest:
renderNow();
return true;
default:
return QWindow::event(event);
}
}
void OpenGLWindow::exposeEvent(QExposeEvent *event)
{
Q_UNUSED(event);
if (isExposed())
renderNow();
}En `renderNow()` salimos si no estamos expuestos en ese momento; en ese caso, el renderizado se retrasa hasta que recibamos efectivamente un evento `expose`. Si aún no lo hemos hecho, creamos el ` QOpenGLContext ` con el mismo ` QSurfaceFormat ` que se estableció en `OpenGLWindow`, y llamamos a `initialize()` para la subclase, y a `initializeOpenGLFunctions()` para que la superclase ` QOpenGLFunctions ` se asocie con el ` QOpenGLContext` correcto. En cualquier caso, establecemos el contexto como actual llamando a ` QOpenGLContext::makeCurrent()`, llamamos a `render()` para realizar el renderizado propiamente dicho y, por último, programamos que el contenido renderizado se haga visible llamando a ` QOpenGLContext::swapBuffers()` con `OpenGLWindow` como parámetro.
Una vez que se inicia el renderizado de un fotograma utilizando un contexto OpenGL mediante la llamada a QOpenGLContext::makeCurrent(), pasando como parámetro la superficie sobre la que se va a renderizar, se pueden emitir los comandos de OpenGL. Los comandos pueden emitirse directamente incluyendo <qopengl.h>, que también incluye los encabezados de OpenGL del sistema, o bien utilizando QOpenGLFunctions, que puede heredarse por comodidad o a la que se puede acceder mediante QOpenGLContext::functions(). QOpenGLFunctions permite acceder a todas las llamadas OpenGL de nivel OpenGL ES 2.0 que aún no son estándar ni en OpenGL ES 2.0 ni en OpenGL de escritorio. Para obtener más información sobre las API de OpenGL y OpenGL ES, consulta el Registro oficial de OpenGL y el Registro de la API de OpenGL ES de Khronos.
Si se ha habilitado la animación con OpenGLWindow::setAnimating(true), llamamos a renderLater() para programar otra solicitud de actualización.
void OpenGLWindow::renderNow()
{
if (!isExposed())
return;
bool needsInitialize = false;
if (!m_context) {
m_context = new QOpenGLContext(this);
m_context->setFormat(requestedFormat());
m_context->create();
needsInitialize = true;
}
m_context->makeCurrent(this);
if (needsInitialize) {
initializeOpenGLFunctions();
initialize();
}
render();
m_context->swapBuffers(this);
if (m_animating)
renderLater();
}Al habilitar la animación también se programa una solicitud de actualización, tal y como se muestra en el siguiente fragmento de código.
void OpenGLWindow::setAnimating(bool animating)
{
m_animating = animating;
if (animating)
renderLater();
}Ejemplo de subclase de renderizado OpenGL
Aquí creamos una subclase de OpenGLWindow para mostrar cómo utilizar OpenGL para renderizar un triángulo giratorio. Al crear indirectamente una subclase de QOpenGLFunctions, obtenemos acceso a todas las funcionalidades propias de OpenGL ES 2.0.
class TriangleWindow : public OpenGLWindow
{
public:
using OpenGLWindow::OpenGLWindow;
void initialize() override;
void render() override;
private:
GLint m_matrixUniform = 0;
QOpenGLBuffer m_vbo;
QOpenGLShaderProgram *m_program = nullptr;
int m_frame = 0;
};En nuestra función principal, inicializamos ` QGuiApplication ` e instanciamos nuestra `TriangleOpenGLWindow`. Le proporcionamos un ` QSurfaceFormat ` especificando que queremos cuatro muestras de antialiasing multimuestra, así como una geometría por defecto. Dado que queremos que haya animación, llamamos a la función `setAnimating()` mencionada anteriormente con el argumento `true`.
int main(int argc, char **argv)
{
QGuiApplication app(argc, argv);
QSurfaceFormat format;
format.setSamples(16);
TriangleWindow window;
window.setFormat(format);
window.resize(640, 480);
window.show();
window.setAnimating(true);
return app.exec();
}El siguiente fragmento de código muestra el programa de shaders de OpenGL utilizado en este ejemplo. Los shaders de vértices y de fragmentos son relativamente sencillos, ya que realizan la transformación de vértices y el coloreado interpolado de los mismos.
static const char *vertexShaderSource = "attribute highp vec4 posAttr;\n"
"attribute lowp vec4 colAttr;\n"
"varying lowp vec4 col;\n"
"uniform highp mat4 matrix;\n"
"void main() {\n"
" col = colAttr;\n"
" gl_Position = matrix * posAttr;\n"
"}\n";
static const char *fragmentShaderSource = "varying lowp vec4 col;\n"
"void main() {\n"
" gl_FragColor = col;\n"
"}\n";Este es el código que carga los sombreadores e inicializa el programa de sombreado. Al utilizar QOpenGLShaderProgram en lugar de OpenGL sin procesar, obtenemos la ventaja de que se eliminan los calificadores «highp», «mediump» y «lowp» en OpenGL para ordenadores de sobremesa, donde no forman parte del estándar. Almacenamos las ubicaciones de los atributos y uniformes en variables miembro para evitar tener que buscar las ubicaciones en cada fotograma.
void TriangleWindow::initialize()
{
static const GLfloat vertices_colors[] = { +0.0f, +0.707f, 1.0f, 0.0f, 0.0f,
-0.5f, -0.500f, 0.0f, 1.0f, 0.0f,
+0.5f, -0.500f, 0.0f, 0.0f, 1.0f };
m_vbo.create();
m_vbo.bind();
m_vbo.allocate(vertices_colors, sizeof(vertices_colors));
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glVertexAttribPointer(0, 2, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat), nullptr);
glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 5 * sizeof(GLfloat),
reinterpret_cast<void *>(2 * sizeof(GLfloat)));
m_program = new QOpenGLShaderProgram(this);
m_program->addShaderFromSourceCode(QOpenGLShader::Vertex, vertexShaderSource);
m_program->addShaderFromSourceCode(QOpenGLShader::Fragment, fragmentShaderSource);
m_program->bindAttributeLocation("posAttr", 0);
m_program->bindAttributeLocation("colAttr", 1);
m_program->link();
m_program->bind();
m_matrixUniform = m_program->uniformLocation("matrix");
Q_ASSERT(m_matrixUniform != -1);
}Por último, aquí está nuestra función render(), donde utilizamos OpenGL para configurar la ventana de visualización, borrar el fondo y renderizar un triángulo giratorio.
void TriangleWindow::render()
{
const qreal retinaScale = devicePixelRatio();
glViewport(0, 0, width() * retinaScale, height() * retinaScale);
glClear(GL_COLOR_BUFFER_BIT);
m_program->bind();
QMatrix4x4 matrix;
matrix.perspective(60.0f, 4.0f / 3.0f, 0.1f, 100.0f);
matrix.translate(0, 0, -2);
matrix.rotate(100.0f * m_frame / screen()->refreshRate(), 0, 1, 0);
m_program->setUniformValue(m_matrixUniform, matrix);
glEnableVertexAttribArray(0);
glEnableVertexAttribArray(1);
glDrawArrays(GL_TRIANGLES, 0, 3);
glDisableVertexAttribArray(0);
glDisableVertexAttribArray(1);
m_program->release();
++m_frame;
}© 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.