Ejemplo de cubo con OpenGL ES 2.0
Muestra cómo girar manualmente un cubo 3D con textura a partir de la entrada del usuario.
El ejemplo «Cubo OpenGL ES 2.0» muestra cómo girar manualmente un cubo 3D con textura a partir de la entrada del usuario, utilizando OpenGL ES 2.0 con Qt. Muestra cómo gestionar eficientemente geometrías poligonales y cómo escribir un sencillo sombreador de vértices y de fragmentos para un canal de procesamiento gráfico programable. Además, muestra cómo utilizar cuaterniones para representar la orientación de objetos 3D.
Este ejemplo se ha escrito para OpenGL ES 2.0, pero también funciona con OpenGL de escritorio, ya que es lo suficientemente sencillo y, en su mayor parte, la API de OpenGL de escritorio es la misma. También se compila sin soporte para OpenGL, pero en ese caso solo muestra una etiqueta que indica que se requiere soporte para OpenGL.

El ejemplo consta de dos clases:
MainWidgethereda de ` QOpenGLWidget ` y contiene la inicialización y el dibujo de OpenGL ES 2.0, así como la gestión de eventos del ratón y del temporizadorGeometryEnginese encarga de las geometrías poligonales. Transfiere la geometría poligonal a objetos de búfer de vértices y dibuja las geometrías a partir de dichos objetos.
Empezaremos inicializando OpenGL ES 2.0 en ` MainWidget`.
Inicialización de OpenGL ES 2.0
Dado que OpenGL ES 2.0 ya no admite una canalización gráfica fija, debemos implementarla nosotros mismos. Esto hace que la canalización gráfica sea muy flexible, pero al mismo tiempo se vuelve más difícil, ya que el usuario tiene que implementarla para que funcione incluso el ejemplo más sencillo. También hace que la canalización gráfica sea más eficiente, ya que el usuario puede decidir qué tipo de canalización se necesita para la aplicación.
En primer lugar, debemos implementar el sombreador de vértices. Este recibe como parámetros los datos de los vértices y la matriz de modelo-vista-proyección (MVP). Transforma la posición de los vértices utilizando la matriz MVP al espacio de pantalla y pasa las coordenadas de textura al sombreador de fragmentos. Las coordenadas de textura se interpolarán automáticamente en las caras de los polígonos.
void main()
{
// Calculate vertex position in screen space
gl_Position = mvp_matrix * a_position;
// Pass texture coordinate to fragment shader
// Value will be automatically interpolated to fragments inside polygon faces
v_texcoord = a_texcoord;
}A continuación, debemos implementar la segunda parte del canal de procesamiento gráfico: el sombreador de fragmentos. Para este ejercicio, debemos implementar un sombreador de fragmentos que se encargue de la texturización. Este recibe como parámetro la coordenada de textura interpolada y busca el color del fragmento en la textura dada.
void main()
{
// Set fragment color from texture
gl_FragColor = texture2D(texture, v_texcoord);
}Mediante QOpenGLShaderProgram podemos compilar, enlazar y vincular el código del sombreador a la canalización gráfica. Este código utiliza archivos de recursos de Qt para acceder al código fuente del sombreador.
void MainWidget::initShaders()
{
// Compile vertex shader
if (!program.addShaderFromSourceFile(QOpenGLShader::Vertex, ":/vshader.glsl"))
close();
// Compile fragment shader
if (!program.addShaderFromSourceFile(QOpenGLShader::Fragment, ":/fshader.glsl"))
close();
// Link shader pipeline
if (!program.link())
close();
// Bind shader pipeline for use
if (!program.bind())
close();
}El siguiente código habilita el búfer de profundidad y el culling de caras ocultas.
// Enable depth buffer
glEnable(GL_DEPTH_TEST);
// Enable back face culling
glEnable(GL_CULL_FACE);Carga de texturas desde archivos de recursos de Qt
La interfaz ` QOpenGLWidget ` implementa métodos para cargar texturas desde ` QImage ` a la memoria de texturas de OpenGL. Aún así, necesitamos utilizar las funciones proporcionadas por OpenGL para especificar la unidad de texturas de OpenGL y configurar las opciones de filtrado de texturas.
void MainWidget::initTextures()
{
// Load cube.png image
texture = new QOpenGLTexture(QImage(":/cube.png").flipped());
// Set nearest filtering mode for texture minification
texture->setMinificationFilter(QOpenGLTexture::Nearest);
// Set bilinear filtering mode for texture magnification
texture->setMagnificationFilter(QOpenGLTexture::Linear);
// Wrap texture coordinates by repeating
// f.ex. texture coordinate (1.1, 1.2) is same as (0.1, 0.2)
texture->setWrapMode(QOpenGLTexture::Repeat);
}Geometría del cubo
Hay muchas formas de renderizar polígonos en OpenGL, pero la más eficiente consiste en utilizar únicamente primitivas de tiras de triángulos y renderizar vértices desde la memoria del hardware gráfico. OpenGL dispone de un mecanismo para crear objetos de búfer en esta área de memoria y transferir datos de vértices a dichos búferes. En la terminología de OpenGL, se denominan «objetos de búfer de vértices» (VBO).

Así es como las caras del cubo se desglosan en triángulos. Los vértices se ordenan de esta manera para que el orden de los vértices sea correcto al utilizar tiras de triángulos. OpenGL determina la cara frontal y la trasera de los triángulos basándose en el orden de los vértices. Por defecto, OpenGL utiliza el orden antihorario para las caras delanteras. Esta información se utiliza en el culling de caras traseras, lo que mejora el rendimiento del renderizado al no renderizar las caras traseras de los triángulos. De esta forma, el pipeline gráfico puede omitir el renderizado de los lados del triángulo que no están orientados hacia la pantalla.
Crear objetos de búfer de vértices y transferirles datos es bastante sencillo utilizando ` QOpenGLBuffer`. `MainWidget` se asegura de que la instancia de `GeometryEngine` se cree y se destruya con el contexto de OpenGL activo. De esta forma, podemos utilizar los recursos de OpenGL en el constructor y realizar la limpieza adecuada en el destructor.
GeometryEngine::GeometryEngine()
: indexBuf(QOpenGLBuffer::IndexBuffer)
{
initializeOpenGLFunctions();
// Generate 2 VBOs
arrayBuf.create();
indexBuf.create();
// Initializes cube geometry and transfers it to VBOs
initCubeGeometry();
}
GeometryEngine::~GeometryEngine()
{
arrayBuf.destroy();
indexBuf.destroy();
}
// Transfer vertex data to VBO 0
arrayBuf.bind();
arrayBuf.allocate(vertices, 24 * sizeof(VertexData));
// Transfer index data to VBO 1
indexBuf.bind();
indexBuf.allocate(indices, 34 * sizeof(GLushort));Dibujar primitivas a partir de VBO e indicar al proceso de renderizado programable cómo localizar los datos de vértices requiere unos pocos pasos. En primer lugar, debemos vincular los VBO que se van a utilizar. A continuación, vinculamos los nombres de los atributos del programa de sombreado y configuramos qué tipo de datos contiene el VBO vinculado. Por último, dibujaremos primitivas de tiras de triángulos utilizando índices del otro VBO.
void GeometryEngine::drawCubeGeometry(QOpenGLShaderProgram *program)
{
// Tell OpenGL which VBOs to use
arrayBuf.bind();
indexBuf.bind();
// Offset for position
quintptr offset = 0;
// Tell OpenGL programmable pipeline how to locate vertex position data
int vertexLocation = program->attributeLocation("a_position");
program->enableAttributeArray(vertexLocation);
program->setAttributeBuffer(vertexLocation, GL_FLOAT, offset, 3, sizeof(VertexData));
// Offset for texture coordinate
offset += sizeof(QVector3D);
// Tell OpenGL programmable pipeline how to locate vertex texture coordinate data
int texcoordLocation = program->attributeLocation("a_texcoord");
program->enableAttributeArray(texcoordLocation);
program->setAttributeBuffer(texcoordLocation, GL_FLOAT, offset, 2, sizeof(VertexData));
// Draw cube geometry using indices from VBO 1
glDrawElements(GL_TRIANGLE_STRIP, 34, GL_UNSIGNED_SHORT, nullptr);
}Proyección en perspectiva
Con los métodos auxiliares de QMatrix4x4 resulta muy sencillo calcular la matriz de proyección en perspectiva. Esta matriz se utiliza para proyectar los vértices en el espacio de la pantalla.
void MainWidget::resizeGL(int w, int h)
{
// Calculate aspect ratio
qreal aspect = qreal(w) / qreal(h ? h : 1);
// Set near plane to 3.0, far plane to 7.0, field of view 45 degrees
const qreal zNear = 3.0, zFar = 7.0, fov = 45.0;
// Reset projection
projection.setToIdentity();
// Set perspective projection
projection.perspective(fov, aspect, zNear, zFar);
}Orientación del objeto 3D
Los cuaterniones son una forma práctica de representar la orientación del objeto 3D. Los cuaterniones implican matemáticas bastante complejas, pero, afortunadamente, todas las operaciones matemáticas necesarias que hay detrás de los cuaterniones están implementadas en QQuaternion. Esto nos permite almacenar la orientación del cubo en un cuaternión, y girar el cubo alrededor de un eje determinado resulta bastante sencillo.
El siguiente código calcula el eje de rotación y la velocidad angular a partir de los eventos del ratón.
void MainWidget::mousePressEvent(QMouseEvent *e)
{
// Save mouse press position
mousePressPosition = QVector2D(e->position());
}
void MainWidget::mouseReleaseEvent(QMouseEvent *e)
{
// Mouse release position - mouse press position
QVector2D diff = QVector2D(e->position()) - mousePressPosition;
// Rotation axis is perpendicular to the mouse position difference
// vector
QVector3D n = QVector3D(diff.y(), diff.x(), 0.0).normalized();
// Accelerate angular speed relative to the length of the mouse sweep
qreal acc = diff.length() / 100.0;
// Calculate new rotation axis as weighted sum
rotationAxis = (rotationAxis * angularSpeed + n * acc).normalized();
// Increase angular speed
angularSpeed += acc;
}QBasicTimer Se utiliza para animar la escena y actualizar la orientación del cubo. Las rotaciones se pueden encadenar simplemente multiplicando cuaterniones.
void MainWidget::timerEvent(QTimerEvent *)
{
// Decrease angular speed (friction)
angularSpeed *= 0.99;
// Stop rotation when speed goes below threshold
if (angularSpeed < 0.01) {
angularSpeed = 0.0;
} else {
// Update rotation
rotation = QQuaternion::fromAxisAndAngle(rotationAxis, angularSpeed) * rotation;
// Request an update
update();
}
}La matriz modelo-vista se calcula utilizando el cuaternión y desplazando el mundo a lo largo del eje Z. Esta matriz se multiplica por la matriz de proyección para obtener la matriz MVP para el programa de sombreado.
// Calculate model view transformation
QMatrix4x4 matrix;
matrix.translate(0.0, 0.0, -5.0);
matrix.rotate(rotation);
// Set modelview-projection matrix
program.setUniformValue("mvp_matrix", projection * matrix);© 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.