Estructura de la Vista Gráfica

Graphics View proporciona una superficie para gestionar e interactuar con un gran número de elementos gráficos 2D personalizados, y un widget de vista para visualizar los elementos, con soporte para zoom y rotación.

El marco incluye una arquitectura de propagación de eventos que permite capacidades de interacción de doble precisión para los elementos de la escena. Los elementos pueden manejar eventos de teclado, pulsación del ratón, movimiento, liberación y doble clic, y también pueden seguir el movimiento del ratón.

La Vista Gráfica utiliza un árbol BSP (Binary Space Partitioning) para proporcionar un descubrimiento de elementos muy rápido, y como resultado de ello, puede visualizar grandes escenas en tiempo real, incluso con millones de elementos.

La Vista Gráfica se introdujo en Qt 4.2, sustituyendo a su predecesor, QCanvas.

Arquitectura de la Vista Gráfica

La Vista Gráfica proporciona un enfoque basado en ítems para la programación modelo-vista, muy similar a las clases de InterView QTableView, QTreeView y QListView. Varias vistas pueden observar una única escena, y la escena contiene elementos de formas geométricas variables.

La escena

QGraphicsScene proporciona la escena de la vista gráfica. La escena tiene las siguientes responsabilidades

• Proporcionar una interfaz rápida para gestionar un gran número de elementos.
• Propagar eventos a cada elemento
• Gestionar el estado de los elementos, como la selección y el enfoque
• Proporcionar funcionalidad de renderizado no transformado, principalmente para impresión.

La escena sirve de contenedor para los objetos de QGraphicsItem. Los elementos se añaden a la escena llamando a QGraphicsScene::addItem(), y luego se recuperan llamando a una de las muchas funciones de descubrimiento de elementos. QGraphicsScene::items() y sus sobrecargas devuelven todos los elementos contenidos o que se cruzan con un punto, un rectángulo, un polígono o un trazado vectorial general. QGraphicsScene::itemAt() devuelve el elemento más alto en un punto determinado. Todas las funciones de descubrimiento de elementos devuelven los elementos en orden de apilamiento descendente (es decir, el primer elemento devuelto es el superior y el último el inferior).

QGraphicsScene scene;
QGraphicsRectItem *rect = scene.addRect(QRectF(0, 0, 100, 100));

QGraphicsItem *item = scene.itemAt(50, 50, QTransform());

QGraphicsSceneLa arquitectura de propagación de eventos de la aplicación programa los eventos de la escena para su envío a los elementos, y también gestiona la propagación entre elementos. Si la escena recibe un evento de pulsación del ratón en una posición determinada, la escena pasa el evento al elemento que se encuentre en esa posición.

QGraphicsScene también gestiona ciertos estados de los elementos, como la selección de elementos y el foco. Puedes seleccionar elementos en la escena llamando a QGraphicsScene::setSelectionArea(), pasándole una forma arbitraria. Esta funcionalidad también se utiliza como base para la selección de banda elástica en QGraphicsView. Para obtener la lista de todos los elementos seleccionados actualmente, llame a QGraphicsScene::selectedItems(). Otro estado manejado por QGraphicsScene es si un elemento tiene o no el foco de entrada del teclado. Puede establecer el enfoque en un elemento llamando a QGraphicsScene::setFocusItem() o QGraphicsItem::setFocus(), u obtener el elemento de enfoque actual llamando a QGraphicsScene::focusItem().

Finalmente, QGraphicsScene te permite renderizar partes de la escena en un dispositivo de pintura a través de la función QGraphicsScene::render(). Puedes leer más sobre esto en la sección Imprimir más adelante en este documento.

La vista

QGraphicsView proporciona el widget de vista, que visualiza el contenido de una escena. Puede adjuntar varias vistas a la misma escena, para proporcionar varios viewports en el mismo conjunto de datos. El widget de vista es un área de desplazamiento, y proporciona barras de desplazamiento para navegar a través de escenas grandes. Para habilitar el soporte OpenGL, puedes establecer un QOpenGLWidget como viewport llamando a QGraphicsView::setViewport().

QGraphicsScene scene;
myPopulateScene(&scene);
QGraphicsView view(&scene);
view.show();

La vista recibe eventos de entrada desde el teclado y el ratón, y los traduce a eventos de escena (convirtiendo las coordenadas utilizadas a coordenadas de escena cuando sea apropiado), antes de enviar los eventos a la escena visualizada.

Utilizando su matriz de transformación, QGraphicsView::transform(), la vista puede transformar el sistema de coordenadas de la escena. Esto permite funciones de navegación avanzadas como el zoom y la rotación. Para mayor comodidad, QGraphicsView también proporciona funciones para traducir entre coordenadas de la vista y de la escena: QGraphicsView::mapToScene() y QGraphicsView::mapFromScene().

El elemento

QGraphicsItem es la clase base para los elementos gráficos de una escena. La Vista Gráfica proporciona varios elementos estándar para formas típicas, como rectángulos (QGraphicsRectItem), elipses (QGraphicsEllipseItem) y elementos de texto (QGraphicsTextItem), pero las características más potentes de QGraphicsItem están disponibles cuando se escribe un elemento personalizado. Entre otras cosas, QGraphicsItem admite las siguientes funciones:

• Eventos de pulsación, movimiento, liberación y doble clic del ratón, así como eventos de mouse hover, eventos de rueda y eventos de menú contextual.
• Foco de entrada del teclado y eventos de tecla
• Arrastrar y soltar
• Agrupación, tanto mediante relaciones padre-hijo como con QGraphicsItemGroup
• Detección de colisiones

Los elementos viven en un sistema de coordenadas local y, al igual que QGraphicsView, también proporciona muchas funciones para asignar coordenadas entre el elemento y la escena, y de elemento a elemento. También, como QGraphicsView, puede transformar su sistema de coordenadas utilizando una matriz: QGraphicsItem::transform(). Esto es útil para rotar y escalar elementos individuales.

Los elementos pueden contener otros elementos (hijos). Las transformaciones de los ítems padres son heredadas por todos sus hijos. Sin embargo, independientemente de la transformación acumulada de un elemento, todas sus funciones (por ejemplo, QGraphicsItem::contains(), QGraphicsItem::boundingRect(), QGraphicsItem::collidesWith()) siguen operando en coordenadas locales.

QGraphicsItem soporta la detección de colisiones a través de la función QGraphicsItem::shape(), y QGraphicsItem::collidesWith(), que son ambas funciones virtuales. Al devolver la forma de tu ítem como una coordenada local QPainterPath desde QGraphicsItem::shape(), QGraphicsItem manejará toda la detección de colisiones por ti. Sin embargo, si quieres proporcionar tu propia detección de colisiones, puedes reimplementar QGraphicsItem::collidesWith().

Clases en el Marco de la Vista Gráfica

Estas clases proporcionan un marco para crear aplicaciones interactivas.

El Sistema de Coordenadas de la Vista Gráfica

La Vista Gráfica está basada en el sistema de coordenadas Cartesianas; la posición de los ítems y la geometría en la escena están representadas por conjuntos de dos números: la coordenada x, y la coordenada y. Cuando se observa una escena utilizando una vista no transformada, una unidad en la escena está representada por un píxel en la pantalla.

Hay tres sistemas de coordenadas efectivos en juego en Vistas Gráficas: Coordenadas de elemento, coordenadas de escena y coordenadas de vista. Para simplificar su implementación, la Vista Gráfica proporciona funciones de conveniencia que le permiten mapear entre los tres sistemas de coordenadas.

Al renderizar, las coordenadas de escena de la Vista Gráfica corresponden a las coordenadas lógicas de QPainter, y las coordenadas de vista son las mismas que las coordenadas de dispositivo. En la documentación del Sistema de Coordenadas, puedes leer sobre la relación entre las coordenadas lógicas y las coordenadas de dispositivo.

Coordenadas de elemento

Los elementos viven en su propio sistema de coordenadas local. Sus coordenadas suelen estar centradas alrededor de su punto central (0, 0), y éste es también el centro para todas las transformaciones. Las primitivas geométricas en el sistema de coordenadas de ítems se denominan a menudo puntos de ítems, líneas de ítems o rectángulos de ítems.

Al crear un elemento personalizado, las coordenadas del elemento son lo único de lo que tienes que preocuparte; QGraphicsScene y QGraphicsView realizarán todas las transformaciones por ti. Esto hace que sea muy fácil implementar elementos personalizados. Por ejemplo, si recibes una pulsación del ratón o un evento de arrastrar y entrar, la posición del evento se da en coordenadas de ítem. La función virtual QGraphicsItem::contains(), que devuelve true si un determinado punto está dentro de tu ítem, y false en caso contrario, toma un argumento de punto en coordenadas del ítem. Del mismo modo, el rectángulo delimitador y la forma de un ítem están en coordenadas de ítem.

La posición de un elemento es la coordenada del punto central del elemento en el sistema de coordenadas de su padre; a veces se denomina coordenadas del padre. En este sentido, la escena se considera el "padre" de todos los objetos sin padre. La posición de los elementos de nivel superior está en coordenadas de escena.

Las coordenadas del hijo son relativas a las coordenadas del padre. Si el elemento hijo no está transformado, la diferencia entre una coordenada hija y una coordenada padre es la misma que la distancia entre los elementos en coordenadas padre. Por ejemplo: Si un elemento hijo no transformado se sitúa exactamente en el punto central de su padre, los sistemas de coordenadas de ambos elementos serán idénticos. Sin embargo, si la posición del elemento hijo es (10, 0), el punto (0, 10) del elemento hijo corresponderá al punto (10, 10) de su elemento padre.

Dado que la posición y la transformación de los elementos son relativas al padre, las coordenadas de los elementos hijos no se ven afectadas por la transformación del padre, aunque la transformación del padre transforma implícitamente al hijo. En el ejemplo anterior, aunque se rote y escale el elemento principal, el punto (0, 10) del elemento secundario seguirá correspondiendo al punto (10, 10) del elemento principal. Sin embargo, en relación con la escena, el hijo seguirá la transformación y posición del padre. Si el padre se escala (2x, 2x), la posición del hijo estará en la coordenada de la escena (20, 0), y su punto (10, 0) se corresponderá con el punto (40, 0) de la escena.

Con QGraphicsItem::pos() como una de las pocas excepciones, las funciones de QGraphicsItem operan en las coordenadas del ítem, independientemente de la transformación del ítem o de cualquiera de sus padres. Por ejemplo, el rectángulo delimitador de un elemento (es decir, QGraphicsItem::boundingRect()) siempre se da en coordenadas de elemento.

Coordenadas de la escena

La escena representa el sistema de coordenadas base para todos sus elementos. El sistema de coordenadas de la escena describe la posición de cada elemento de nivel superior, y también constituye la base para todos los eventos de escena enviados a la escena desde la vista. Cada elemento de la escena tiene una posición de escena y un rectángulo delimitador (QGraphicsItem::scenePos(), QGraphicsItem::sceneBoundingRect()), además de su posición de elemento local y su rectángulo delimitador. La posición en la escena describe la posición del elemento en las coordenadas de la escena, y su rectángulo delimitador de la escena constituye la base para que QGraphicsScene determine qué áreas de la escena han cambiado. Los cambios en la escena se comunican a través de la señal QGraphicsScene::changed(), y el argumento es una lista de rectángulos de escena.

Coordenadas de la vista

Las coordenadas de la vista son las coordenadas del widget. Cada unidad en coordenadas de vista corresponde a un píxel. Lo especial de este sistema de coordenadas es que es relativo al widget, o viewport, y no se ve afectado por la escena observada. La esquina superior izquierda de la vista de QGraphicsView es siempre (0, 0), y la esquina inferior derecha es siempre (ancho de la vista, alto de la vista). Todos los eventos de ratón y de arrastrar y soltar se reciben originalmente como coordenadas de vista, y necesitas mapear estas coordenadas a la escena para poder interactuar con los elementos.

Asignación de coordenadas

A menudo, cuando se trata con elementos en una escena, puede ser útil mapear coordenadas y formas arbitrarias de la escena a un elemento, de un elemento a otro, o de la vista a la escena. Por ejemplo, cuando haces clic con el ratón en la ventana de QGraphicsView, puedes preguntar a la escena qué elemento está bajo el cursor llamando a QGraphicsView::mapToScene(), seguido de QGraphicsScene::itemAt(). Si quieres saber en qué parte de la vista se encuentra un elemento, puedes llamar a QGraphicsItem::mapToScene() en el elemento y, a continuación, a QGraphicsView::mapFromScene() en la vista. Por último, si desea saber qué elementos se encuentran dentro de una elipse de vista, puede pasar QPainterPath a mapToScene() y, a continuación, pasar la ruta asignada a QGraphicsScene::items().

Puede asignar coordenadas y formas a y desde la escena de un elemento llamando a QGraphicsItem::mapToScene() y QGraphicsItem::mapFromScene(). También puedes mapear al elemento padre de un elemento llamando a QGraphicsItem::mapToParent() y QGraphicsItem::mapFromParent(), o entre elementos llamando a QGraphicsItem::mapToItem() y QGraphicsItem::mapFromItem(). Todas las funciones de mapeo pueden mapear puntos, rectángulos, polígonos y rutas.

Las mismas funciones de mapeo están disponibles en la vista, para mapear hacia y desde la escena. QGraphicsView::mapFromScene() y QGraphicsView::mapToScene(). Para mapear desde una vista a un ítem, primero se mapea a la escena, y luego se mapea desde la escena al ítem.

Funciones clave

Zoom y rotación

QGraphicsView soporta las mismas transformaciones afines que QPainter a través de QGraphicsView::setMatrix(). Aplicando una transformación a la vista, puedes añadir fácilmente soporte para funciones de navegación comunes como el zoom y la rotación.

He aquí un ejemplo de cómo implementar ranuras de zoom y rotación en una subclase de QGraphicsView:

class View : public QGraphicsView
{
Q_OBJECT
    //...
public slots:
    void zoomIn() { scale(1.2, 1.2); }
    void zoomOut() { scale(1 / 1.2, 1 / 1.2); }
    void rotateLeft() { rotate(-10); }
    void rotateRight() { rotate(10); }
    //...
};

Las ranuras podrían estar conectadas a QToolButtons con autoRepeat habilitado.

QGraphicsView mantiene el centro de la vista alineado cuando se transforma la vista.

Ver también el ejemplo de Nodos Elásticos para el código que muestra cómo implementar funciones básicas de zoom.

Impresión

La Vista Gráfica proporciona impresión de una sola línea a través de sus funciones de renderizado, QGraphicsScene::render() y QGraphicsView::render(). Las funciones proporcionan la misma API: Puedes hacer que la escena o la vista rendericen todo o parte de su contenido en cualquier dispositivo de pintura pasando un QPainter a cualquiera de las funciones de renderizado. Este ejemplo muestra como imprimir toda la escena en una página completa, usando QPrinter.

QGraphicsScene scene;
QPrinter printer;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

if (QPrintDialog(&printer).exec() == QDialog::Accepted) {
    QPainter painter(&printer);
    painter.setRenderHint(QPainter::Antialiasing);
    scene.render(&painter);
}

La diferencia entre las funciones de renderizado de escena y de vista es que una opera en coordenadas de escena, y la otra en coordenadas de vista. QGraphicsScene::render() es a menudo preferida para imprimir segmentos enteros de una escena sin transformar, como para trazar datos geométricos, o para imprimir un documento de texto. QGraphicsView::render(), por otro lado, es adecuado para hacer capturas de pantalla; su comportamiento por defecto es renderizar el contenido exacto de la ventana gráfica utilizando el pintor proporcionado.

QGraphicsScene scene;
scene.addRect(QRectF(0, 0, 100, 200), QPen(Qt::black), QBrush(Qt::green));

QPixmap pixmap;
QPainter painter(&pixmap);
painter.setRenderHint(QPainter::Antialiasing);
scene.render(&painter);
painter.end();

pixmap.save("scene.png");

Cuando los tamaños de las áreas de origen y destino no coinciden, los contenidos de origen se estiran para encajar en el área de destino. Pasando un Qt::AspectRatioMode a la función de renderizado que esté utilizando, puede elegir mantener o ignorar la relación de aspecto de la escena cuando se estiren los contenidos.

Arrastrar y soltar

Dado que QGraphicsView hereda indirectamente de QWidget, ya proporciona la misma funcionalidad de arrastrar y soltar que QWidget. Además, por conveniencia, el marco de la Vista Gráfica proporciona soporte de arrastrar y soltar para la escena, y para todos y cada uno de los elementos. Cuando la vista recibe un arrastre, traduce los eventos de arrastrar y soltar en un QGraphicsSceneDragDropEvent, que se reenvía a la escena. La escena se hace cargo de la programación de este evento, y lo envía al primer elemento bajo el cursor del ratón que acepte arrastres.

Para iniciar un arrastre desde un ítem, crea un objeto QDrag, pasando un puntero al widget que inicia el arrastre. Los elementos pueden ser observados por muchas vistas al mismo tiempo, pero sólo una vista puede iniciar el arrastre. Los arrastres se inician en la mayoría de los casos como resultado de pulsar o mover el ratón, por lo que en mousePressEvent() o mouseMoveEvent(), puede obtener el puntero del widget de origen del evento. Por ejemplo:

void CustomItem::mousePressEvent(QGraphicsSceneMouseEvent *event)
{
    QMimeData *data = new QMimeData;
    QDrag *drag = new QDrag(event->widget());
    drag->setMimeData(data);
    drag->exec();
}

Para interceptar eventos de arrastrar y soltar para la escena, debes reimplementar QGraphicsScene::dragEnterEvent() y cualquier manejador de eventos que tu escena particular necesite, en una subclase de QGraphicsItem. Puedes leer más sobre arrastrar y soltar en la Vista Gráfica en la documentación de cada uno de los manejadores de eventos de QGraphicsScene.

Los ítems pueden habilitar el soporte de arrastrar y soltar llamando a QGraphicsItem::setAcceptDrops(). Para manejar el arrastre entrante, reimplemente QGraphicsItem::dragEnterEvent(), QGraphicsItem::dragMoveEvent(), QGraphicsItem::dragLeaveEvent(), y QGraphicsItem::dropEvent().

Vea también el ejemplo del Robot de Arrastrar y Soltar para una demostración del soporte de la Vista Gráfica para operaciones de arrastrar y soltar.

Cursores y Tooltips

Como QWidget, QGraphicsItem también soporta cursores (QGraphicsItem::setCursor()), y tooltips (QGraphicsItem::setToolTip()). Los cursores y la información sobre herramientas se activan mediante QGraphicsView cuando el cursor del ratón entra en el área del elemento (se detecta llamando a QGraphicsItem::contains()).

También puede establecer un cursor por defecto directamente en la vista llamando a QGraphicsView::setCursor().

Ver también el ejemplo del Robot de Arrastrar y Soltar para el código que implementa la información sobre herramientas y el manejo de la forma del cursor.

Animación

La Vista Gráfica soporta animación a varios niveles. Puedes ensamblar animaciones fácilmente usando el Animation Framework. Para ello necesitarás que tus ítems hereden de QGraphicsObject y asociarles QPropertyAnimation. QPropertyAnimation permite animar cualquier propiedad de QObject.

Otra opción es crear un elemento personalizado que herede de QObject y QGraphicsItem. El elemento puede configurar sus propios temporizadores y controlar las animaciones con pasos incrementales en QObject::timerEvent().

Una tercera opción, que está disponible sobre todo por compatibilidad con QCanvas en Qt 3, es avanzar la escena llamando a QGraphicsScene::advance(), que a su vez llama a QGraphicsItem::advance().

Renderizado OpenGL

Para habilitar el renderizado OpenGL, simplemente establece un nuevo QOpenGLWidget como la vista de QGraphicsView llamando a QGraphicsView::setViewport(). Si quieres OpenGL con antialiasing, necesitas crear un QSurfaceFormat con el número de muestras necesario (ver QSurfaceFormat::setSamples()).

Ejemplo:

QGraphicsView view(&scene);
QOpenGLWidget *gl = new QOpenGLWidget();
QSurfaceFormat format;
format.setSamples(4);
gl->setFormat(format);
view.setViewport(gl);

Grupos de elementos

Haciendo que un elemento sea hijo de otro, puedes conseguir la característica más esencial de la agrupación de elementos: los elementos se moverán juntos, y todas las transformaciones se propagan de padre a hijo.

Además, QGraphicsItemGroup es un elemento especial que combina la gestión de eventos hijo con una interfaz útil para añadir y eliminar elementos de un grupo. Al añadir un elemento a QGraphicsItemGroup se mantendrá su posición y transformación originales, mientras que al reparentar elementos en general, el elemento hijo se reposicionará con respecto a su nuevo padre. Para mayor comodidad, puede crear QGraphicsItemGroups a través de la escena llamando a QGraphicsScene::createItemGroup().

Widgets y diseños

Qt 4.4 introdujo soporte para elementos de geometría y diseño a través de QGraphicsWidget. Este elemento base especial es similar a QWidget, pero a diferencia de QWidget, no hereda de QPaintDevice; sino de QGraphicsItem. Esto te permite escribir widgets completos con eventos, señales y ranuras, sugerencias de tamaño y políticas, y también puedes gestionar las geometrías de tus widgets en layouts a través de QGraphicsLinearLayout y QGraphicsGridLayout.

QGraphicsWidget

Basándose en las capacidades de QGraphicsItem y en su reducido tamaño, QGraphicsWidget proporciona lo mejor de ambos mundos: funcionalidad adicional de QWidget, como el estilo, la fuente, la paleta, la dirección del diseño y su geometría, e independencia de la resolución y soporte de transformación de QGraphicsItem. Dado que la vista gráfica utiliza coordenadas reales en lugar de enteras, las funciones de geometría de QGraphicsWidget también operan en QRectF y QPointF. Esto también se aplica a los recuadros, márgenes y espaciado de los marcos. Con QGraphicsWidget no es raro especificar márgenes de contenido de (0,5, 0,5, 0,5, 0,5), por ejemplo. Se pueden crear tanto subwidgets como ventanas de "nivel superior"; en algunos casos se puede utilizar ahora la Vista Gráfica para aplicaciones MDI avanzadas.

Algunas de las propiedades de QWidget son compatibles, incluidos los indicadores y atributos de ventana, pero no todas. Consulte la documentación de la clase QGraphicsWidget para obtener una descripción completa de lo que se admite y lo que no. Por ejemplo, puedes crear ventanas decoradas pasando el indicador de ventana Qt::Window al constructor QGraphicsWidget, pero la Vista Gráfica no soporta actualmente los indicadores Qt::Sheet y Qt::Drawer que son comunes en macOS.

QGraphicsLayout

QGraphicsLayout forma parte de un marco de diseño de segunda generación diseñado específicamente para QGraphicsWidget. Su API es muy similar a la de QLayout. Puedes gestionar widgets y subdisposiciones dentro de QGraphicsLinearLayout y QGraphicsGridLayout. También puedes escribir fácilmente tu propia disposición subclasificando QGraphicsLayout tú mismo, o añadir tus propios elementos QGraphicsItem a la disposición escribiendo una subclase adaptadora de QGraphicsLayoutItem.

Soporte para widgets integrados

La Vista Gráfica proporciona soporte sin fisuras para incrustar cualquier widget en la escena. Puede incrustar widgets sencillos, como QLineEdit o QPushButton, widgets complejos, como QTabWidget, e incluso ventanas principales completas. Para incrustar tu widget en la escena, simplemente llama a QGraphicsScene::addWidget(), o crea una instancia de QGraphicsProxyWidget para incrustar tu widget manualmente.

A través de QGraphicsProxyWidget, Graphics View es capaz de integrar en profundidad las características del widget cliente, incluidos sus cursores, información sobre herramientas, eventos de ratón, tableta y teclado, widgets hijos, animaciones, ventanas emergentes (por ejemplo, QComboBox o QCompleter), y el foco de entrada y la activación del widget. QGraphicsProxyWidget integra incluso el orden de tabulación del widget incrustado para que pueda entrar y salir de los widgets incrustados. Incluso puede incrustar un nuevo QGraphicsView en su escena para proporcionar escenas anidadas complejas.

Al transformar un widget incrustado, la Vista Gráfica se asegura de que el widget se transforme con independencia de la resolución, lo que permite que las fuentes y el estilo se mantengan nítidos al ampliar la imagen. (Ten en cuenta que el efecto de la independencia de la resolución depende del estilo).

Rendimiento

Instrucciones de coma flotante

Para poder aplicar transformaciones y efectos a los elementos con precisión y rapidez, la Vista Gráfica se ha construido asumiendo que el hardware del usuario es capaz de proporcionar un rendimiento razonable para las instrucciones de coma flotante.

Muchas estaciones de trabajo y ordenadores de sobremesa están equipados con hardware adecuado para acelerar este tipo de computación, pero algunos dispositivos integrados sólo pueden proporcionar bibliotecas para manejar operaciones matemáticas o emular instrucciones de coma flotante en software.

Como consecuencia, ciertos tipos de efectos pueden ser más lentos de lo esperado en determinados dispositivos. Es posible compensar esta pérdida de rendimiento con optimizaciones en otras áreas, por ejemplo, utilizando OpenGL para renderizar una escena. Sin embargo, estas optimizaciones pueden reducir el rendimiento si dependen de la presencia de hardware de coma flotante.