Ejemplo de ratones que chocan
Muestra cómo animar elementos en una vista gráfica.
El ejemplo «Ratones que chocan» muestra cómo utilizar el marco de trabajo de la vista gráfica para implementar elementos animados y detectar colisiones entre ellos.

«Graphics View» proporciona la clase « QGraphicsScene » para gestionar e interactuar con un gran número de elementos gráficos 2D personalizados derivados de la clase « QGraphicsItem », así como un widget « QGraphicsView » para visualizar los elementos, con soporte para el zoom y la rotación.
El ejemplo consta de una clase de elemento y una función principal: la clase ` Mouse ` representa a los ratones individuales que heredan de ` QGraphicsItem`, y la función ` main() ` proporciona la ventana principal de la aplicación.
En primer lugar, analizaremos la clase « Mouse » para ver cómo animar los elementos y detectar colisiones entre ellos; a continuación, analizaremos la función « main() » para ver cómo colocar los elementos en una escena y cómo implementar la vista correspondiente.
Definición de la clase «Mouse»
La clase ` mouse ` hereda de ` QGraphicsItem`. La clase ` QGraphicsItem ` es la clase base para todos los elementos gráficos del marco de trabajo de Graphics View y proporciona una base ligera para escribir tus propios elementos personalizados.
class Mouse : public QGraphicsItem
{
public:
Mouse();
QRectF boundingRect() const override;
QPainterPath shape() const override;
void paint(QPainter *painter, const QStyleOptionGraphicsItem *option,
QWidget *widget) override;
protected:
void advance(int step) override;
private:
qreal angle = 0;
qreal speed = 0;
qreal mouseEyeDirection = 0;
QColor color;
};Al crear un elemento gráfico personalizado, debes implementar las dos funciones públicas virtuales puras de ` QGraphicsItem`: ` boundingRect()` —que devuelve una estimación del área pintada por el elemento— y ` paint()` —que implementa el proceso de pintura propiamente dicho—. Además, reimplementamos ` shape()` y ` advance()`. Reimplementamos shape() para que devuelva la forma exacta de nuestro elemento «mouse»; la implementación por defecto se limita a devolver el rectángulo delimitador del elemento. Reimplementamos advance() para gestionar la animación de modo que todo se realice en una sola actualización.
Definición de la clase «Mouse»
Al crear un elemento «mouse», primero nos aseguramos de que todas las variables privadas del elemento que aún no se hayan inicializado directamente en la clase se inicialicen correctamente:
Mouse::Mouse() : color(QRandomGenerator::global()->bounded(256),
QRandomGenerator::global()->bounded(256),
QRandomGenerator::global()->bounded(256))
{
setRotation(QRandomGenerator::global()->bounded(360 * 16));
}Para calcular los distintos componentes del color del ratón, utilizamos QRandomGenerator.
A continuación, llamamos a la función ` setRotation()` heredada de ` QGraphicsItem`. Los elementos se sitúan en su propio sistema de coordenadas local. Sus coordenadas suelen estar centradas en (0, 0), y este es también el centro de todas las transformaciones. Al llamar a la función ` setRotation()` del elemento, modificamos la dirección en la que el ratón comenzará a moverse.
Cuando el ` QGraphicsScene ` decide avanzar la escena un fotograma, llamará a ` QGraphicsItem::advance()` en cada uno de los elementos. Esto nos permite animar nuestro ratón utilizando nuestra reimplementación de la función `advance()`.
void Mouse::advance(int step)
{
if (!step)
return;
QLineF lineToCenter(QPointF(0, 0), mapFromScene(0, 0));
if (lineToCenter.length() > 150) {
qreal angleToCenter = std::atan2(lineToCenter.dy(), lineToCenter.dx());
angleToCenter = normalizeAngle((Pi - angleToCenter) + Pi / 2);
if (angleToCenter < Pi && angleToCenter > Pi / 4) {
// Rotate left
angle += (angle < -Pi / 2) ? 0.25 : -0.25;
} else if (angleToCenter >= Pi && angleToCenter < (Pi + Pi / 2 + Pi / 4)) {
// Rotate right
angle += (angle < Pi / 2) ? 0.25 : -0.25;
}
} else if (::sin(angle) < 0) {
angle += 0.25;
} else if (::sin(angle) > 0) {
angle -= 0.25;
}En primer lugar, no nos molestamos en realizar ningún avance si el paso es 0. Esto se debe a que advance() se llama dos veces: una vez con step == 0, lo que indica que los elementos están a punto de avanzar, y luego con step == 1 para el avance propiamente dicho. También nos aseguramos de que el ratón permanezca dentro de un círculo con un radio de 150 píxeles.
Fíjate en la función mapFromScene() proporcionada por QGraphicsItem. Esta función mapea una posición dada en coordenadas de escena al sistema de coordenadas del elemento.
const QList<QGraphicsItem *> dangerMice = scene()->items(QPolygonF()
<< mapToScene(0, 0)
<< mapToScene(-30, -50)
<< mapToScene(30, -50));
for (const QGraphicsItem *item : dangerMice) {
if (item == this)
continue;
QLineF lineToMouse(QPointF(0, 0), mapFromItem(item, 0, 0));
qreal angleToMouse = std::atan2(lineToMouse.dy(), lineToMouse.dx());
angleToMouse = normalizeAngle((Pi - angleToMouse) + Pi / 2);
if (angleToMouse >= 0 && angleToMouse < Pi / 2) {
// Rotate right
angle += 0.5;
} else if (angleToMouse <= TwoPi && angleToMouse > (TwoPi - Pi / 2)) {
// Rotate left
angle -= 0.5;
}
}
if (dangerMice.size() > 1 && QRandomGenerator::global()->bounded(10) == 0) {
if (QRandomGenerator::global()->bounded(1))
angle += QRandomGenerator::global()->bounded(1 / 500.0);
else
angle -= QRandomGenerator::global()->bounded(1 / 500.0);
}A continuación, intentamos evitar colisiones con otros ratones.
speed += (-50 + QRandomGenerator::global()->bounded(100)) / 100.0;
qreal dx = ::sin(angle) * 10;
mouseEyeDirection = (qAbs(dx / 5) < 1) ? 0 : dx / 5;
setRotation(rotation() + dx);
setPos(mapToParent(0, -(3 + sin(speed) * 3)));
}Por último, calculamos la velocidad del ratón y la dirección de su mirada (para utilizarla al dibujar el ratón) y establecemos su nueva posición.
La posición de un elemento describe su origen (coordenada local (0, 0)) en las coordenadas del padre. La función QGraphicsItem::setPos() establece la posición del elemento en la posición dada en el sistema de coordenadas del padre. En el caso de los elementos sin padre, la posición indicada se interpreta como coordenadas de la escena. QGraphicsItem también proporciona una función mapToParent() para mapear una posición dada en coordenadas del elemento al sistema de coordenadas del padre. Si el elemento no tiene padre, la posición se mapeará al sistema de coordenadas de la escena.
A continuación, es el momento de proporcionar una implementación para las funciones virtuales puras heredadas de ` QGraphicsItem`. Echemos primero un vistazo a la función ` boundingRect()`:
QRectF Mouse::boundingRect() const
{
qreal adjust = 0.5;
return QRectF(-18 - adjust, -22 - adjust,
36 + adjust, 60 + adjust);
}La función ` boundingRect()` define los límites exteriores del elemento como un rectángulo. Ten en cuenta que el marco de trabajo Graphics View utiliza el rectángulo delimitador para determinar si es necesario volver a dibujar el elemento, por lo que todo el dibujo debe realizarse dentro de este rectángulo.
void Mouse::paint(QPainter *painter, const QStyleOptionGraphicsItem *, QWidget *)
{
// Body
painter->setBrush(color);
painter->drawEllipse(-10, -20, 20, 40);
// Eyes
painter->setBrush(Qt::white);
painter->drawEllipse(-10, -17, 8, 8);
painter->drawEllipse(2, -17, 8, 8);
// Nose
painter->setBrush(Qt::black);
painter->drawEllipse(QRectF(-2, -22, 4, 4));
// Pupils
painter->drawEllipse(QRectF(-8.0 + mouseEyeDirection, -17, 4, 4));
painter->drawEllipse(QRectF(4.0 + mouseEyeDirection, -17, 4, 4));
// Ears
painter->setBrush(scene()->collidingItems(this).isEmpty() ? Qt::darkYellow : Qt::red);
painter->drawEllipse(-17, -12, 16, 16);
painter->drawEllipse(1, -12, 16, 16);
// Tail
QPainterPath path(QPointF(0, 20));
path.cubicTo(-5, 22, -5, 22, 0, 25);
path.cubicTo(5, 27, 5, 32, 0, 30);
path.cubicTo(-5, 32, -5, 42, 0, 35);
painter->setBrush(Qt::NoBrush);
painter->drawPath(path);
}El marco de trabajo Graphics View llama a la función paint() para dibujar el contenido del elemento; la función dibuja el elemento en coordenadas locales.
Fíjate en el dibujo de las orejas: cada vez que un elemento del ratón choca con otros elementos del ratón, sus orejas se rellenan de rojo; en caso contrario, se rellenan de amarillo oscuro. Utilizamos la función ` QGraphicsScene::collidingItems()` para comprobar si hay algún ratón con el que colisionar. La detección real de colisiones la gestiona el marco de trabajo Graphics View mediante la intersección entre formas. Lo único que tenemos que hacer es asegurarnos de que la función ` QGraphicsItem::shape()` devuelva una forma precisa para nuestro elemento:
QPainterPath Mouse::shape() const
{
QPainterPath path;
path.addRect(-10, -20, 20, 40);
return path;
}Dado que la complejidad de la intersección entre dos formas arbitrarias aumenta en un orden de magnitud cuando las formas son complejas, esta operación puede llevar bastante tiempo. Un enfoque alternativo consiste en reimplementar la función collidesWithItem() para proporcionar tu propio algoritmo personalizado de colisión entre elementos y formas.
Con esto queda completada la implementación de la clase ` Mouse `; ya está lista para su uso. Echemos un vistazo a la función ` main() ` para ver cómo implementar una escena para los ratones y una vista para mostrar el contenido de la escena.
La función Main()
La función ` main() ` proporciona la ventana principal de la aplicación, además de crear los elementos, su escena y la vista correspondiente.
int main(int argc, char **argv)
{
QApplication app(argc, argv);En primer lugar, creamos un objeto de aplicación y creamos la escena:
QGraphicsScene scene;
scene.setSceneRect(-300, -300, 600, 600);La clase ` QGraphicsScene ` sirve como contenedor para los `QGraphicsItems`. También proporciona funcionalidad que permite determinar de forma eficiente la ubicación de los elementos, así como identificar qué elementos son visibles dentro de un área arbitraria de la escena.
Al crear una escena, se recomienda establecer el rectángulo de la escena, es decir, el rectángulo que define la extensión de la misma. Lo utiliza principalmente QGraphicsView para determinar el área desplazable por defecto de la vista, y QGraphicsScene para gestionar la indexación de los elementos. Si no se establece explícitamente, el rectángulo predeterminado de la escena será el rectángulo delimitador más grande de todos los elementos de la escena desde que se creó esta. Esto significa que el rectángulo crecerá cuando se añadan o se muevan elementos en la escena, pero nunca se reducirá.
scene.setItemIndexMethod(QGraphicsScene::NoIndex);La función de índice de elementos se utiliza para agilizar la búsqueda de elementos. NoIndex implica que la localización de elementos tiene una complejidad lineal, ya que se buscan todos los elementos de la escena. Sin embargo, añadir, mover y eliminar elementos se realiza en tiempo constante. Este enfoque es ideal para escenas dinámicas, en las que se añaden, mueven o eliminan muchos elementos de forma continua. La alternativa es BspTreeIndex, que utiliza una búsqueda binaria para lograr algoritmos de localización de elementos con una complejidad más cercana a la logarítmica.
for (int i = 0; i < MouseCount; ++i) {
Mouse *mouse = new Mouse;
mouse->setPos(::sin((i * 6.28) / MouseCount) * 200,
::cos((i * 6.28) / MouseCount) * 200);
scene.addItem(mouse);
}A continuación, añadimos los ratones a la escena.
QGraphicsView view(&scene);
view.setRenderHint(QPainter::Antialiasing);
view.setBackgroundBrush(QPixmap(":/images/cheese.jpg"));Para poder visualizar la escena, también debemos crear un widget ` QGraphicsView `. La clase ` QGraphicsView ` visualiza el contenido de una escena en una ventana de visualización desplazable. También nos aseguramos de que el contenido se renderice utilizando suavizado, y creamos el fondo de queso configurando el pincel de fondo de la vista.
La imagen utilizada para el fondo se almacena como un archivo binario en el ejecutable de la aplicación mediante el sistema de recursos de Qt. El constructor de ` QPixmap ` acepta tanto nombres de archivo que hacen referencia a archivos reales en el disco como nombres de archivo que hacen referencia a los recursos incrustados de la aplicación.
view.setCacheMode(QGraphicsView::CacheBackground);
view.setViewportUpdateMode(QGraphicsView::BoundingRectViewportUpdate);
view.setDragMode(QGraphicsView::ScrollHandDrag);A continuación, configuramos el modo de caché; ` QGraphicsView ` puede almacenar en caché contenido prerenderizado en un mapa de píxeles, que luego se dibuja en la ventana de visualización. El objetivo de este almacenamiento en caché es acelerar el tiempo total de renderizado de las áreas que tardan más en renderizarse, por ejemplo: texturas, degradados y fondos con mezcla alfa. La propiedad CacheMode indica qué partes de la vista se almacenan en caché, y el indicador CacheBackground habilita el almacenamiento en caché del fondo de la vista.
Al establecer la propiedad dragMode, definimos qué debe ocurrir cuando el usuario hace clic en el fondo de la escena y arrastra el ratón. El indicador ScrollHandDrag hace que el cursor se convierta en una mano que señala, y al arrastrar el ratón se desplazarán las barras de desplazamiento.
view.setWindowTitle(QT_TRANSLATE_NOOP(QGraphicsView, "Colliding Mice"));
view.resize(400, 300);
view.show();
QTimer timer;
QObject::connect(&timer, &QTimer::timeout, &scene, &QGraphicsScene::advance);
timer.start(1000 / 33);
return app.exec();
}Por último, establecemos el título y el tamaño de la ventana de la aplicación antes de entrar en el bucle de eventos principal mediante la función ` QApplication::exec()`.
Por último, creamos un ` QTimer ` y conectamos su señal `timeout()` a la ranura `advance()` de la escena. Cada vez que se active el temporizador, la escena avanzará un fotograma.
A continuación, indicamos al temporizador que se active cada 1000/33 milisegundos. Esto nos dará una frecuencia de 30 fotogramas por segundo, lo cual es lo suficientemente rápido para la mayoría de las animaciones. Realizar la animación con una única conexión al temporizador para hacer avanzar la escena garantiza que todos los ratones se muevan al mismo tiempo y, lo que es más importante, que solo se envíe una actualización a la pantalla una vez que todos los ratones se hayan movido.
© 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.