Ejemplo de pintura en 2D
El ejemplo de pintura en 2D muestra cómo se pueden utilizar conjuntamente QPainter y QOpenGLWidget para mostrar gráficos 2D acelerados en hardware compatible.

La clase ` QPainter ` se utiliza para dibujar primitivas gráficas 2D en dispositivos de pintura proporcionados por las subclases de ` QPaintDevice `, tales como ` QWidget ` y ` QImage`.
Dado que ` QOpenGLWidget ` es una subclase de ` QWidget`, es posible reimplementar su método ` paintEvent()` y utilizar ` QPainter ` para dibujar en el dispositivo, tal y como se haría con un ` QWidget`. La única diferencia es que las operaciones de dibujo se acelerarán por hardware si los controladores OpenGL de su sistema lo admiten.
En este ejemplo, realizamos las mismas operaciones de dibujo en un ` QWidget ` y un ` QOpenGLWidget`. El ` QWidget ` se muestra con el suavizado activado, y el ` QOpenGLWidget ` también utilizará el suavizado si el controlador OpenGL de tu sistema admite las extensiones necesarias.
Resumen
Para poder comparar los resultados de dibujar en una subclase de ` QOpenGLWidget ` con el dibujo nativo en una subclase de ` QWidget `, queremos mostrar ambos tipos de widget uno al lado del otro. Para ello, derivamos subclases de ` QWidget ` y ` QOpenGLWidget`, utilizando una clase independiente ` Helper ` para realizar las mismas operaciones de dibujo en cada una, y las colocamos en un widget de nivel superior, proporcionado a su vez por la clase ` Window `.
Definición de la clase auxiliar
En este ejemplo, las operaciones de dibujo las lleva a cabo una clase auxiliar. Hacemos esto porque queremos que se realicen las mismas operaciones de dibujo tanto para nuestra subclase ` QWidget ` como para la subclase ` QOpenGLWidget `.
La clase ` Helper ` es muy sencilla:
class Helper
{
public:
Helper();
public:
void paint(QPainter *painter, QPaintEvent *event, int elapsed);
private:
QBrush background;
QBrush circleBrush;
QFont textFont;
QPen circlePen;
QPen textPen;
};Aparte del constructor, solo proporciona una función ` paint() ` para dibujar utilizando un «pintor» proporcionado por una de nuestras subclases de widget.
Implementación de la clase auxiliar
El constructor de la clase configura los recursos que necesita para dibujar contenido en un widget:
Helper::Helper()
{
QLinearGradient gradient(QPointF(50, -20), QPointF(80, 20));
gradient.setColorAt(0.0, Qt::white);
gradient.setColorAt(1.0, QColor(0xa6, 0xce, 0x39));
background = QBrush(QColor(64, 32, 64));
circleBrush = QBrush(gradient);
circlePen = QPen(Qt::black);
circlePen.setWidth(1);
textPen = QPen(Qt::white);
textFont.setPixelSize(50);
}El dibujo propiamente dicho se lleva a cabo en la función ` paint() `. Esta función toma un ` QPainter ` que ya ha sido configurado para dibujar en un dispositivo de dibujo (ya sea un ` QWidget ` o un ` QOpenGLWidget`), un ` QPaintEvent ` que proporciona información sobre la región que se va a dibujar y una medida del tiempo transcurrido (en milisegundos) desde la última actualización del dispositivo de dibujo.
void Helper::paint(QPainter *painter, QPaintEvent *event, int elapsed)
{
painter->fillRect(event->rect(), background);
painter->translate(100, 100);Comenzamos a dibujar rellenando la región contenida en el evento de dibujo antes de trasladar el origen del sistema de coordenadas, de modo que el resto de las operaciones de dibujo se desplacen hacia el centro del dispositivo de dibujo.
Dibujamos un patrón en espiral formado por círculos, utilizando el tiempo transcurrido especificado para animarlos de modo que parezcan moverse hacia fuera y alrededor del origen del sistema de coordenadas:
painter->save();
painter->setBrush(circleBrush);
painter->setPen(circlePen);
painter->rotate(elapsed * 0.030);
qreal r = elapsed / 1000.0;
int n = 30;
for (int i = 0; i < n; ++i) {
painter->rotate(30);
qreal factor = (i + r) / n;
qreal radius = 0 + 120.0 * factor;
qreal circleRadius = 1 + factor * 20;
painter->drawEllipse(QRectF(radius, -circleRadius,
circleRadius * 2, circleRadius * 2));
}
painter->restore();Dado que el sistema de coordenadas gira muchas veces durante este proceso, guardamos previamente el estado del ` QPainter` mediante ` save()` y lo recuperamos después con ` restore()`.
painter->setPen(textPen);
painter->setFont(textFont);
painter->drawText(QRect(-50, -50, 100, 100), Qt::AlignCenter, QStringLiteral("Qt"));
}Dibujamos algo de texto en el origen para completar el efecto.
Definición de la clase de widget
La clase ` Widget ` proporciona un widget personalizado básico que utilizamos para mostrar la animación sencilla dibujada por la clase ` Helper `.
class Helper;
class Widget : public QWidget
{
Q_OBJECT
public:
Widget(Helper *helper, QWidget *parent);
public slots:
void animate();
protected:
void paintEvent(QPaintEvent *event) override;
private:
Helper *helper;
int elapsed;
};Aparte del constructor, solo contiene una función paintEvent(), que nos permite dibujar contenido personalizado, y un slot que se utiliza para animar su contenido. Una variable miembro lleva la cuenta de la clase Helper que utiliza el widget para dibujar su contenido, y la otra registra el tiempo transcurrido desde su última actualización.
Implementación de la clase de widget
El constructor solo inicializa las variables de miembro, almacenando el objeto ` Helper ` proporcionado y llamando al constructor de la clase base, y establece un tamaño fijo para el widget:
Widget::Widget(Helper *helper, QWidget *parent)
: QWidget(parent), helper(helper)
{
elapsed = 0;
setFixedSize(200, 200);
}La ranura « animate() » se invoca cada vez que un temporizador —que definiremos más adelante— agota su tiempo de espera:
void Widget::animate()
{
elapsed = (elapsed + qobject_cast<QTimer*>(sender())->interval()) % 1000;
update();
}Aquí determinamos el intervalo transcurrido desde la última vez que el temporizador agotó su tiempo de espera y lo sumamos a cualquier valor existente antes de volver a dibujar el widget. Dado que la animación utilizada en la clase ` Helper ` se repite cada segundo, podemos utilizar el operador módulo para garantizar que la variable ` elapsed ` sea siempre menor que 1000.
Dado que la clase ` Helper ` se encarga de todo el proceso de dibujo, solo tenemos que implementar un evento de dibujo que establezca una variable ` QPainter ` para el widget y llame a la función ` paint() ` del ayudante:
void Widget::paintEvent(QPaintEvent *event)
{
QPainter painter;
painter.begin(this);
painter.setRenderHint(QPainter::Antialiasing);
helper->paint(&painter, event, elapsed);
painter.end();
}Definición de la clase GLWidget
La definición de la clase ` GLWidget ` es básicamente la misma que la de la clase ` Widget `, salvo que deriva de ` QOpenGLWidget`.
class Helper;
class GLWidget : public QOpenGLWidget
{
Q_OBJECT
public:
GLWidget(Helper *helper, QWidget *parent);
public slots:
void animate();
protected:
void paintEvent(QPaintEvent *event) override;
private:
Helper *helper;
int elapsed;
};De nuevo, las variables de miembro registran el ` Helper ` utilizado para dibujar el widget y el tiempo transcurrido desde la última actualización.
Implementación de la clase `GLWidget`
El constructor difiere ligeramente del de la clase ` Widget `:
GLWidget::GLWidget(Helper *helper, QWidget *parent)
: QOpenGLWidget(parent), helper(helper)
{
elapsed = 0;
setFixedSize(200, 200);
setAutoFillBackground(false);
}Se inicializa la variable miembro ` elapsed ` y se almacena el objeto ` Helper ` utilizado para dibujar el widget.
La ranura ` animate() ` es exactamente igual a la que proporciona la clase ` Widget `:
void GLWidget::animate()
{
elapsed = (elapsed + qobject_cast<QTimer*>(sender())->interval()) % 1000;
update();
}El ` paintEvent() ` es prácticamente idéntico al que se encuentra en la clase ` Widget `:
void GLWidget::paintEvent(QPaintEvent *event)
{
QPainter painter;
painter.begin(this);
painter.setRenderHint(QPainter::Antialiasing);
helper->paint(&painter, event, elapsed);
painter.end();
}Dado que el suavizado se activará si está disponible, solo tenemos que configurar un ` QPainter ` en el widget y llamar a la función ` paint() ` del ayudante para mostrar el contenido del widget.
Definición de la clase Window
La clase « Window » tiene una definición básica y minimalista:
class Window : public QWidget
{
Q_OBJECT
public:
Window();
private:
Helper helper;
};Contiene un único objeto ` Helper ` que se compartirá entre todos los widgets.
Implementación de la clase «Window»
El constructor se encarga de todo el trabajo: crea un widget de cada tipo y los inserta, junto con sus etiquetas, en un diseño:
Window::Window()
{
setWindowTitle(tr("2D Painting on Native and OpenGL Widgets"));
Widget *native = new Widget(&helper, this);
GLWidget *openGL = new GLWidget(&helper, this);
QLabel *nativeLabel = new QLabel(tr("Native"));
nativeLabel->setAlignment(Qt::AlignHCenter);
QLabel *openGLLabel = new QLabel(tr("OpenGL"));
openGLLabel->setAlignment(Qt::AlignHCenter);
QGridLayout *layout = new QGridLayout;
layout->addWidget(native, 0, 0);
layout->addWidget(openGL, 0, 1);
layout->addWidget(nativeLabel, 1, 0);
layout->addWidget(openGLLabel, 1, 1);
setLayout(layout);
QTimer *timer = new QTimer(this);
connect(timer, &QTimer::timeout, native, &Widget::animate);
connect(timer, &QTimer::timeout, openGL, &GLWidget::animate);
timer->start(50);
}Se crea un temporizador con un tiempo de espera de 50 milisegundos con fines de animación, y se conecta a las ranuras « animate() » de los objetos « Widget » y « GLWidget ». Una vez iniciados, los widgets deberían actualizarse a unos 20 fotogramas por segundo.
Ejecución del ejemplo
El ejemplo muestra las mismas operaciones de dibujo realizadas al mismo tiempo en un Widget y un GLWidget. La calidad y la velocidad de renderizado en el GLWidget dependen del nivel de compatibilidad con el multimuestreo y la aceleración por hardware que ofrezca el controlador OpenGL de tu sistema. Si falta la compatibilidad con cualquiera de estas características, el controlador podría recurrir a un renderizador de software que sacrifique calidad a cambio de velocidad.
© 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.