La Unidad de procesamiento central (CPU) y la Unidad de procesamiento de gráficos (GPU) de su computadora interactúan en cada momento que está usando su computadora para brindarle una interfaz visual nítida y receptiva. Siga leyendo para comprender mejor cómo funcionan juntos.
Foto por sskennel .
La sesión de preguntas y respuestas de hoy nos llega por cortesía de SuperUser, una subdivisión de Stack Exchange, un grupo de sitios web de preguntas y respuestas impulsado por la comunidad.
La pregunta
El lector de superusuario Sathya planteó la pregunta:
Aquí puede ver una captura de pantalla de un pequeño programa de C ++ llamado Triangle.exe con un triángulo giratorio basado en la API de OpenGL.
Es cierto que es un ejemplo muy básico, pero creo que es aplicable a otras operaciones de tarjetas gráficas.
Solo tenía curiosidad y quería saber todo el proceso desde hacer doble clic en Triangle.exe en Windows XP hasta que pueda ver el triángulo girando en el monitor. ¿Qué sucede, cómo interactúan la CPU (que primero maneja el .exe) y la GPU (que finalmente muestra el triángulo en la pantalla)?
Supongo que en la visualización de este triángulo giratorio se encuentra principalmente el siguiente hardware / software, entre otros:
Hardware
- HDD
- Memoria del sistema (RAM)
- UPC
- Memoria de video
- GPU
- pantalla LCD
Software
- Sistema operativo
- API de DirectX / OpenGL
- Controlador de Nvidia
¿Alguien puede explicar el proceso, tal vez con algún tipo de diagrama de flujo como ilustración?
No debería ser una explicación compleja que cubra cada paso (supongo que iría más allá del alcance), sino una explicación que puede seguir un técnico de TI intermedio.
Estoy bastante seguro de que muchas personas que incluso se llamarían profesionales de TI no podrían describir este proceso correctamente.
La respuesta
Aunque varios miembros de la comunidad respondieron la pregunta, Oliver Salzburg hizo un esfuerzo adicional y la respondió no solo con una respuesta detallada, sino también con excelentes gráficos de acompañamiento.
Imagen de JasonC, disponible como fondo de pantalla aquí .
El escribe:
Decidí escribir un poco sobre el aspecto de la programación y cómo los componentes se comunican entre sí. Tal vez arroje algo de luz sobre ciertas áreas.
La presentación
¿Qué se necesita para tener esa única imagen que publicaste en tu pregunta dibujada en la pantalla?
Hay muchas formas de dibujar un triángulo en la pantalla. Para simplificar, supongamos que no se utilizaron búferes de vértice. (UN búfer de vértice es un área de memoria donde almacena coordenadas). Supongamos que el programa simplemente le dijo a la canalización de procesamiento de gráficos sobre cada vértice (un vértice es solo una coordenada en el espacio) en una fila.
Pero , antes de que podamos dibujar algo, primero tenemos que ejecutar algunos andamios. Ya veremos por qué luego:
// Limpiar la pantalla y el búfer de profundidad glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); // Restablecer la matriz de ModelView actual glMatrixMode (GL_MODELVIEW); glLoadIdentity (); // Dibujar usando triángulos glBegin (GL_TRIANGLES); // Rojo glColor3f (1.0f, 0.0f, 0.0f); // Parte superior del triángulo (frente) glVertex3f (0.0f, 1.0f, 0.0f); // Verde glColor3f (0.0f, 1.0f, 0.0f); // Izquierda del triángulo (frente) glVertex3f (-1.0f, -1.0f, 1.0f); // Azul glColor3f (0.0f, 0.0f, 1.0f); // Derecha del triángulo (frente) glVertex3f (1.0f, -1.0f, 1.0f); // Dibujo terminado glEnd ();
Entonces, ¿qué hizo eso?
Cuando escribe un programa que quiere usar la tarjeta gráfica, generalmente elige algún tipo de interfaz para el controlador. Algunas interfaces conocidas para el controlador son:
- OpenGL
- Direct3D
- Milagros
Para este ejemplo, nos quedaremos con OpenGL. Ahora tu interfaz con el conductor es lo que le brinda todas las herramientas que necesita para hacer su programa hablar a la tarjeta gráfica (o al controlador, que luego negociaciones a la tarjeta).
Esta interfaz seguramente le proporcionará herramientas . Estas herramientas toman la forma de un FUEGO al que puede llamar desde su programa.
Esa API es lo que vemos que se usa en el ejemplo anterior. Miremos más de cerca.
El andamio
Antes de que realmente puedas hacer un dibujo real, tendrás que realizar un preparar . Tienes que definir tu ventana gráfica (el área que realmente se renderizará), tu perspectiva (la cámara en tu mundo), qué anti-aliasing usarás (para suavizar los bordes de tu triángulo) ...
Pero no miraremos nada de eso. Solo echaremos un vistazo a las cosas que tendrás que hacer cada cuadro . Me gusta:
Limpiar la pantalla
La canalización de gráficos no va a borrar la pantalla en cada fotograma. Tendrás que contarlo. ¿Por qué? Esta es la razón por:
Si no borra la pantalla, simplemente
dibujar sobre
es cada fotograma. Por eso llamamos
glClear
con el
GL_COLOR_BUFFER_BIT
conjunto. La otra parte (
GL_DEPTH_BUFFER_BIT
) le dice a OpenGL que borre el
profundidad
buffer. Este búfer se utiliza para determinar qué píxeles están delante (o detrás) de otros píxeles.
Transformación
La transformación es la parte donde tomamos todas las coordenadas de entrada (los vértices de nuestro triángulo) y aplicamos nuestra matriz ModelView. Esta es la matriz que explica como nuestro modelo (los vértices) se rotan, escalan y trasladan (mueven).
A continuación, aplicamos nuestra matriz de proyección. Esto mueve todas las coordenadas para que estén de frente a nuestra cámara correctamente.
Ahora nos transformamos una vez más, con nuestra matriz Viewport. Hacemos esto para escalar nuestro modelo al tamaño de nuestro monitor. ¡Ahora tenemos un conjunto de vértices que están listos para ser renderizados!
Volveremos a la transformación un poco más tarde.
Dibujo
Para dibujar un triángulo, simplemente podemos decirle a OpenGL que inicie un nuevo
lista de triángulos
llamando
glBegin
con el
GL_TRIANGLES
constante.
También hay otras formas que puedes dibujar. Como un
tira triangular
o un
ventilador triangular
. Se trata principalmente de optimizaciones, ya que requieren menos comunicación entre la CPU y la GPU para dibujar la misma cantidad de triángulos.
Después de eso, podemos proporcionar una lista de conjuntos de 3 vértices que deberían formar cada triángulo. Cada triángulo usa 3 coordenadas (ya que estamos en el espacio 3D). Además, también proporciono un
color
para cada vértice, llamando
glColor3f
antes de
vocación
glVertex3f
.
La sombra entre los 3 vértices (las 3 esquinas del triángulo) es calculada por OpenGL automáticamente . Interpolará el color en toda la cara del polígono.
Interacción
Ahora, al hacer clic en la ventana. La aplicación solo tiene que capturar la mensaje de ventana que señala el clic. Entonces puede ejecutar cualquier acción en su programa que desee.
Esto consigue un lote más difícil una vez que desee comenzar a interactuar con su escena 3D.
Primero debe saber claramente en qué píxel el usuario hizo clic en la ventana. Entonces, tomando tu perspectiva en cuenta, puede calcular la dirección de un rayo, desde el punto del clic del mouse en su escena. Luego puede calcular si algún objeto en su escena se cruza con ese rayo . Ahora sabe si el usuario hizo clic en un objeto.
Entonces, ¿cómo lo haces girar?
Transformación
Soy consciente de dos tipos de transformaciones que se aplican generalmente:
- Transformación basada en matrices
- Transformación basada en huesos
La diferencia es que huesos afectar soltero vértices . Las matrices siempre afectan a todos los vértices dibujados de la misma manera. Veamos un ejemplo.
Ejemplo
Anteriormente, cargamos nuestro matriz de identidad antes de dibujar nuestro triángulo. La matriz de identidad es aquella que simplemente proporciona sin transformación en absoluto. Entonces, lo que sea que dibuje, solo se ve afectado por mi perspectiva. Entonces, el triángulo no se rotará en absoluto.
Si quiero rotarlo ahora, podría hacer los cálculos yo mismo (en la CPU) y simplemente llamar
glVertex3f
con
otro
coordenadas (que se rotan). O podría dejar que la GPU haga todo el trabajo, llamando
glRotatef
antes de dibujar:
// Rotar el triángulo en el eje Y glRotatef (cantidad, 0.0f, 1.0f, 0.0f);
cantidad
es, por supuesto, solo un valor fijo. Si quieres
animado
, tendrás que realizar un seguimiento de
cantidad
y aumentarlo en cada fotograma.
Entonces, espera, ¿qué pasó con toda la charla de matrix antes?
En este sencillo ejemplo, no tenemos que preocuparnos por las matrices. Simplemente llamamos
glRotatef
y se encarga de todo eso por nosotros.
glRotateproduce una rotación deángulogrados alrededor del vector x y z. La matriz actual (ver glMatrixMode ) se multiplica por una matriz de rotación con el producto reemplazando la matriz actual, como si glMultMatrix fueron llamados con la siguiente matriz como argumento:x 2 1 - c + cx y 1 - c - z sx z 1 - c + y s 0 y x 1 - c + z sy 2 1 - c + cy z 1 - c - x s 0 x z 1 - c - y sy z 1 - c + x sz 2 1 - c + c 0 0 0 0 1
Bueno, gracias por eso!
Conclusión
Lo que se vuelve obvio es que se habla mucho a OpenGL. Pero no lo dice nos cualquier cosa. ¿Dónde está la comunicación?
Lo único que OpenGL nos dice en este ejemplo es cuando este hecho . Cada operación tomará una cierta cantidad de tiempo. Algunas operaciones tardan muchísimo, otras son increíblemente rápidas.
Enviar un vértice a la GPU será tan rápido que ni siquiera sabría cómo expresarlo. Enviar miles de vértices desde la CPU a la GPU, cada fotograma, probablemente no sea ningún problema.
Limpiar la pantalla puede tardar un milisegundo o algo peor (tenga en cuenta que, por lo general, solo tiene unos 16 milisegundos de tiempo para dibujar cada cuadro), según el tamaño de su ventana gráfica. Para borrarlo, OpenGL tiene que dibujar cada píxel en el color que desea borrar, que podrían ser millones de píxeles.
Aparte de eso, prácticamente solo podemos preguntarle a OpenGL sobre las capacidades de nuestro adaptador de gráficos (resolución máxima, suavizado máximo, profundidad de color máxima,…).
Pero también podemos rellenar una textura con píxeles, cada uno de los cuales tiene un color específico. Por tanto, cada píxel tiene un valor y la textura es un “archivo” gigante lleno de datos. Podemos cargar eso en la tarjeta gráfica (creando un búfer de textura), luego cargar un sombreador , dile a ese sombreador que use nuestra textura como entrada y ejecute algunos cálculos extremadamente pesados en nuestro "archivo".
Luego podemos "renderizar" el resultado de nuestro cálculo (en forma de nuevos colores) en una nueva textura.
Así es como puede hacer que la GPU funcione para usted de otras formas. Asumo que CUDA tiene un desempeño similar a ese aspecto, pero nunca tuve la oportunidad de trabajar con él.
En realidad, solo tocamos ligeramente todo el tema. La programación de gráficos 3D es una bestia infernal.
¿Tiene algo que agregar a la explicación? Habla en los comentarios. ¿Quieres leer más respuestas de otros usuarios de Stack Exchange expertos en tecnología? Consulte el hilo de discusión completo aquí .
