Decidí escribir un poco sobre el aspecto de 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 imagen única, que publicaste en tu pregunta, dibujada en la pantalla?
Hay muchas formas de dibujar un triángulo en la pantalla. Por simplicidad, supongamos que no se usaron buffers de vértices. (Un búfer de vértices es un área de memoria donde almacena coordenadas.) Supongamos que el programa simplemente le dijo a la tubería de procesamiento de gráficos sobre cada vértice individual (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. Veremos por qué más tarde:
// Clear The Screen And The Depth Buffer
glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
// Reset The Current Modelview Matrix
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// Drawing Using Triangles
glBegin(GL_TRIANGLES);
// Red
glColor3f(1.0f,0.0f,0.0f);
// Top Of Triangle (Front)
glVertex3f( 0.0f, 1.0f, 0.0f);
// Green
glColor3f(0.0f,1.0f,0.0f);
// Left Of Triangle (Front)
glVertex3f(-1.0f,-1.0f, 1.0f);
// Blue
glColor3f(0.0f,0.0f,1.0f);
// Right Of Triangle (Front)
glVertex3f( 1.0f,-1.0f, 1.0f);
// Done Drawing
glEnd();
Entonces, ¿qué hizo eso?
Cuando escribe un programa que quiere usar la tarjeta gráfica, generalmente elegirá algún tipo de interfaz para el controlador. Algunas interfaces conocidas para el controlador son:
Para este ejemplo nos quedaremos con OpenGL. Ahora, su interfaz con el controlador es lo que le brinda todas las herramientas que necesita para que su programa se comunique con la tarjeta gráfica (o el controlador, que luego se comunica con la tarjeta).
Esta interfaz seguramente le dará ciertas herramientas . Estas herramientas toman la forma de una API a la 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 una configuración . Tienes que definir tu ventana gráfica (el área que realmente se representará), tu perspectiva (la cámara en tu mundo), qué suavizado usarás (para suavizar los bordes de tu triángulo) ...
Pero no veremos nada de eso. Solo echaremos un vistazo a las cosas que tendrás que hacer en cada fotograma . Me gusta:
Borrar la pantalla
La canalización de gráficos no va a limpiar la pantalla para usted en cada cuadro. Tendrás que contarlo. ¿Por qué? Esta es la razón por:
Si no limpia la pantalla, simplemente dibujará sobre ella cada fotograma. Por eso llamamos glClearcon el GL_COLOR_BUFFER_BITset. El otro bit ( GL_DEPTH_BUFFER_BIT) le dice a OpenGL que borre el búfer de profundidad . Este búfer se usa para determinar qué píxeles están delante (o detrás) de otros píxeles.
Transformación
Fuente de imagen
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 cómo nuestro modelo (los vértices) se rotan, escalan y traducen (mueven).
A continuación, aplicamos nuestra matriz de proyección. Esto mueve todas las coordenadas para que se enfrenten 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 listos para renderizarse!
Volveremos a la transformación un poco más tarde.
Dibujo
Para dibujar un triángulo, simplemente podemos decirle a OpenGL que comience una nueva lista de triángulos llamando glBegincon la GL_TRIANGLESconstante.
También hay otras formas que puedes dibujar. Como una tira triangular o un abanico triangular . Estas son principalmente 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 llamar glVertex3f.
OpenGL calcula automáticamente la sombra entre los 3 vértices (las 3 esquinas del triángulo) . Interpolará el color sobre toda la cara del polígono.
Interacción
Ahora, cuando haces clic en la ventana. La aplicación solo tiene que capturar el mensaje de la ventana que indica el clic. Luego puede ejecutar cualquier acción en su programa que desee.
Esto se vuelve mucho más difícil una vez que quieres comenzar a interactuar con tu escena 3D.
Primero debe saber claramente en qué píxel el usuario hizo clic en la ventana. Luego, teniendo en cuenta su perspectiva , 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 ya sabe si el usuario hizo clic en un objeto.
Entonces, ¿cómo haces que gire?
Transformación
Soy consciente de dos tipos de transformaciones que generalmente se aplican:
- Transformación basada en matriz
- Transformación ósea
La diferencia es que los huesos afectan vértices individuales . Las matrices siempre afectan a todos los vértices dibujados de la misma manera. Veamos un ejemplo.
Ejemplo
Anteriormente, cargamos nuestra matriz de identidad antes de dibujar nuestro triángulo. La matriz de identidad es aquella que simplemente no proporciona transformación alguna . 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 glVertex3fcon otras coordenadas (que se rotan). O podría dejar que la GPU haga todo el trabajo, llamando glRotatefantes de dibujar:
// Rotate The Triangle On The Y axis
glRotatef(amount,0.0f,1.0f,0.0f);
amountes, por supuesto, solo un valor fijo. Si desea animar , tendrá que realizar un seguimiento amounty aumentarlo cada fotograma.
Entonces, espera, ¿qué pasó con todas las conversaciones matriciales anteriores?
En este simple ejemplo, no tenemos que preocuparnos por las matrices. Simplemente llamamos glRotatefy se encarga de todo eso por nosotros.
glRotateproduce una rotación de anglegrados alrededor del vector xyz. La matriz actual (ver glMatrixMode ) se multiplica por una matriz de rotación con el producto reemplazando la matriz actual, como si se llamara a glMultMatrix 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 con OpenGL. Pero no nos dice nada. ¿Dónde está la comunicación?
Lo único que nos dice OpenGL en este ejemplo es cuándo está hecho . Cada operación tomará una cierta cantidad de tiempo. Algunas operaciones toman un tiempo increíblemente largo, 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 cuadro, es muy probable que no sea un problema.
Limpiar la pantalla puede tomar un milisegundo o peor (tenga en cuenta que generalmente solo tiene unos 16 milisegundos de tiempo para dibujar cada fotograma), dependiendo de qué tan grande sea 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, 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 llenar una textura con píxeles que tienen un color específico. 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 , decirle al sombreador que use nuestra textura como entrada y ejecutar algunos cálculos extremadamente pesados en nuestro "archivo".
Entonces 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 maneras. Supongo que CUDA funciona de manera similar a ese aspecto, pero nunca tuve la oportunidad de trabajar con él.
Realmente solo tocamos un poco todo el tema. La programación de gráficos en 3D es una bestia infernal.
Fuente de imagen
