P r o g r a m a c i ó n c o n De D e l p h i y Op O p e n GL GL
Carlos García Trujillo
[email protected] http://glscene.tripod.com
(Cedida la publicación a el Rinconcito de Delphi) http://www.elrinconcito.com/delphi/
Prohibida la reproducción o modificación sin autorización e x pr e sa de l au to r .
Delphi en tres dimensiones Un vistazo a las API’s de gráficos 3D Quiero hablar un poco acerca de las opciones que tenemos para realizar aplicaciones que involucren gráficos 3D en Delphi, ya sean salvapantallas, juegos, demos multimedia, interfaces 3D, e incluso simulaciones y aplicaciones de realidad virtual. Así que mencionaremos las características mas relevantes de las dos API’s gráficas de mayor importancia en el mundo de las computadoras personales: Direct3D y OpenGL. ¿Que por qué usar una de estas API’s? Los motivos son varios: ahorrarnos tiempo de trabajo, permitir un amplio soporte de hardware y lograr código fácilmente portable.
Direct3D Direct3D es el API 3D de Microsoft. Es un completo conjunto de servicios de gráficos 3D tanto de transformaciones, iluminación y renderizado de escenas, así como de acceso transparente a la aceleración por hardware y una comprensible solución 3D para la nueva generación de PC’s. Es la última adición al altamente popular conjunto de API’s Microsoft® DirectX™ de tecnología multimedia. Este conjunto incluye las API’s DirectDraw™, DirectSound™, DirectInput™ y DirectPlay™. Direct3D proporciona acceso a avanzadas capacidades gráficas de aceleradores 3D por vía hardware, tales como el z-buffering (que se usa para registrar la proximidad de un objeto al observador, y es también crucial para el eliminado de superficies ocultas), antializado de líneas (reduce los bordes escalonados en las líneas dibujadas sobre una pantalla), transparencias, efectos atmosféricos, y correcta perspectiva del mapeado de texturas. Entre las desventajas que podríamos enumerar de Direct3D es que es una interfaz complicada y poco portable. Sin embargo, si queremos que nuestras aplicaciones gráficas corran bajo Windows 9x soportando aceleración de hardware en casi todas las tarjetas del mercado y al mismo tiempo funcionen sin tarjetas aceleradoras o saquen provecho del MMX y los microprocesadores que vendrán sin tener que programar las rutinas de rasterización por software aparte, la única opción es Direct3D. Aquí cabe hacer mención que Direct3D soporta un juego de chips gráficos mucho más amplio que el soportado por OpenGL, y esta es una de las razones por las que este sea tan popular en el área del desarrollo de juegos para PC’s, y que muchas empresas de desarrollo de este tipo de aplicaciones basen sus programas en esta API. Direct3D es el API elegida para portar juegos de consolas como Playstation a PC. Los programadores de Delphi tenemos mucho de donde escoger en cuanto a Direct3D, ya que existen en Internet una gran cantidad de componentes y librerías freeware que funcionan como interfaz entre Delphi y DirectX. Entre los componentes más relevantes que podemos mencionar respecto a DirectX con Delphi están los famosos DelphiX de Hiroyuki Hori, y los agregados que se han escrito para esta librería, como el TCollisionTester3DX de Henrik Fabricius, entre otros. Y qué decir además de la suite de componentes Delphi Games Creator , la cual también se distribuye de manera
gratuita y es una muy sencilla y práctica interfaz entre Delphi y la gran mayoría de funcionalidades de DirectX.
OpenGL OpenGL es una librería gráfica escrita originalmente en C que permite la manipulación de gráficos 3D a todos los niveles. Esta librería se concibió para programar en máquinas nativas Silicon Graphics bajo el nombre de GL (Graphics Library). Posteriormente se consideró la posibilidad de extenderla a cualquier tipo de plataforma y asegurar así su portabilidad y extensibilidad de uso con lo que se llegó al término Open Graphics Library Graphics Library, es decir, OpenGL. La librería se ejecuta a la par con nuestro programa independientemente de la capacidad gráfica de la máquina que usamos. Esto significa que la ejecución se dará por software a no ser que contemos con hardware gráfico específico en nuestra máquina. Si contamos con tarjetas aceleradoras de vídeo, tecnología MMX, aceleradoras 3D, pipelines gráficos implementados en placa, etc ... gozaremos por supuesto de una ejecución muchísimo más rápida en tiempo real. Así esta librería puede usarse bajo todo tipo de sistemas operativos e incluso usando una gran variedad de lenguajes de programación. Podemos encontrar variantes de OpenGL para Windows 95/NT, Unix, Linux, Iris, Solaris, Java e incluso lenguajes de programación visuales como Visual Basic, Borland C++ Builder y por supuesto Delphi. En contraste con la antigua IRIS GL-library de SGI, OpenGL es por diseño independiente de plataformas y sistemas operativos como ya lo mencionamos, y esto es un punto que podemos tomar en cuenta los programadores de Delphi, pensando en que próximamente saldrá una versión de Delphi para Linux, en la que obviamente no podremos contar con DirectX. Además es perceptiva a la red, de manera que es posible separar nuestra aplicación OpenGL en un servidor y un cliente que verdaderamente produzca los gráficos. Existe un protocolo para mover por la red los comandos OpenGL entre el servidor y el cliente. Gracias a su independencia del sistema operativo, el servidor y el cliente no tiene porque ejecutarse en el mismo tipo de plataforma, muy a menudo el servidor será una supercomputadora ejecutando una compleja simulación y el cliente una simple estación de trabajo mayormente dedicada a la visualización gráfica. OpenGL permite al desarrollador escribir aplicaciones que se puedan desplegar en varias plataformas fácilmente. Por encima de todo, OpenGL es una biblioteca estilizada de trazado de gráficos de alto rendimiento, y hay varias tarjetas gráficas aceleradoras y especializadas en 3D que implementan primitivas OpenGL a nivel del hardware. Hasta hace poco, estas avanzadas bibliotecas gráficas solían ser muy caras y sólo estaban disponibles para estaciones SGI u otras estaciones de trabajo UNIX. Las cosas están cambiando muy deprisa y gracias a las generosas licencias y el kit de desarrollo de controladores de SGI, vamos a ver más y más hardware OpenGL para usuarios de PC’s. Al contrario de Direct3D, OpenGL es un API altamente portable y sencilla . Lo de sencilla es más bien en comparación con Direct3D, ya que para poder comprender la mayor parte de las funciones de OpenGL es necesario tener un poco de conocimientos de Algebra Lineal, Geometría y un poco de 2
Delphi en tres dimensiones Un vistazo a las API’s de gráficos 3D Quiero hablar un poco acerca de las opciones que tenemos para realizar aplicaciones que involucren gráficos 3D en Delphi, ya sean salvapantallas, juegos, demos multimedia, interfaces 3D, e incluso simulaciones y aplicaciones de realidad virtual. Así que mencionaremos las características mas relevantes de las dos API’s gráficas de mayor importancia en el mundo de las computadoras personales: Direct3D y OpenGL. ¿Que por qué usar una de estas API’s? Los motivos son varios: ahorrarnos tiempo de trabajo, permitir un amplio soporte de hardware y lograr código fácilmente portable.
Direct3D Direct3D es el API 3D de Microsoft. Es un completo conjunto de servicios de gráficos 3D tanto de transformaciones, iluminación y renderizado de escenas, así como de acceso transparente a la aceleración por hardware y una comprensible solución 3D para la nueva generación de PC’s. Es la última adición al altamente popular conjunto de API’s Microsoft® DirectX™ de tecnología multimedia. Este conjunto incluye las API’s DirectDraw™, DirectSound™, DirectInput™ y DirectPlay™. Direct3D proporciona acceso a avanzadas capacidades gráficas de aceleradores 3D por vía hardware, tales como el z-buffering (que se usa para registrar la proximidad de un objeto al observador, y es también crucial para el eliminado de superficies ocultas), antializado de líneas (reduce los bordes escalonados en las líneas dibujadas sobre una pantalla), transparencias, efectos atmosféricos, y correcta perspectiva del mapeado de texturas. Entre las desventajas que podríamos enumerar de Direct3D es que es una interfaz complicada y poco portable. Sin embargo, si queremos que nuestras aplicaciones gráficas corran bajo Windows 9x soportando aceleración de hardware en casi todas las tarjetas del mercado y al mismo tiempo funcionen sin tarjetas aceleradoras o saquen provecho del MMX y los microprocesadores que vendrán sin tener que programar las rutinas de rasterización por software aparte, la única opción es Direct3D. Aquí cabe hacer mención que Direct3D soporta un juego de chips gráficos mucho más amplio que el soportado por OpenGL, y esta es una de las razones por las que este sea tan popular en el área del desarrollo de juegos para PC’s, y que muchas empresas de desarrollo de este tipo de aplicaciones basen sus programas en esta API. Direct3D es el API elegida para portar juegos de consolas como Playstation a PC. Los programadores de Delphi tenemos mucho de donde escoger en cuanto a Direct3D, ya que existen en Internet una gran cantidad de componentes y librerías freeware que funcionan como interfaz entre Delphi y DirectX. Entre los componentes más relevantes que podemos mencionar respecto a DirectX con Delphi están los famosos DelphiX de Hiroyuki Hori, y los agregados que se han escrito para esta librería, como el TCollisionTester3DX de Henrik Fabricius, entre otros. Y qué decir además de la suite de componentes Delphi Games Creator , la cual también se distribuye de manera
gratuita y es una muy sencilla y práctica interfaz entre Delphi y la gran mayoría de funcionalidades de DirectX.
OpenGL OpenGL es una librería gráfica escrita originalmente en C que permite la manipulación de gráficos 3D a todos los niveles. Esta librería se concibió para programar en máquinas nativas Silicon Graphics bajo el nombre de GL (Graphics Library). Posteriormente se consideró la posibilidad de extenderla a cualquier tipo de plataforma y asegurar así su portabilidad y extensibilidad de uso con lo que se llegó al término Open Graphics Library Graphics Library, es decir, OpenGL. La librería se ejecuta a la par con nuestro programa independientemente de la capacidad gráfica de la máquina que usamos. Esto significa que la ejecución se dará por software a no ser que contemos con hardware gráfico específico en nuestra máquina. Si contamos con tarjetas aceleradoras de vídeo, tecnología MMX, aceleradoras 3D, pipelines gráficos implementados en placa, etc ... gozaremos por supuesto de una ejecución muchísimo más rápida en tiempo real. Así esta librería puede usarse bajo todo tipo de sistemas operativos e incluso usando una gran variedad de lenguajes de programación. Podemos encontrar variantes de OpenGL para Windows 95/NT, Unix, Linux, Iris, Solaris, Java e incluso lenguajes de programación visuales como Visual Basic, Borland C++ Builder y por supuesto Delphi. En contraste con la antigua IRIS GL-library de SGI, OpenGL es por diseño independiente de plataformas y sistemas operativos como ya lo mencionamos, y esto es un punto que podemos tomar en cuenta los programadores de Delphi, pensando en que próximamente saldrá una versión de Delphi para Linux, en la que obviamente no podremos contar con DirectX. Además es perceptiva a la red, de manera que es posible separar nuestra aplicación OpenGL en un servidor y un cliente que verdaderamente produzca los gráficos. Existe un protocolo para mover por la red los comandos OpenGL entre el servidor y el cliente. Gracias a su independencia del sistema operativo, el servidor y el cliente no tiene porque ejecutarse en el mismo tipo de plataforma, muy a menudo el servidor será una supercomputadora ejecutando una compleja simulación y el cliente una simple estación de trabajo mayormente dedicada a la visualización gráfica. OpenGL permite al desarrollador escribir aplicaciones que se puedan desplegar en varias plataformas fácilmente. Por encima de todo, OpenGL es una biblioteca estilizada de trazado de gráficos de alto rendimiento, y hay varias tarjetas gráficas aceleradoras y especializadas en 3D que implementan primitivas OpenGL a nivel del hardware. Hasta hace poco, estas avanzadas bibliotecas gráficas solían ser muy caras y sólo estaban disponibles para estaciones SGI u otras estaciones de trabajo UNIX. Las cosas están cambiando muy deprisa y gracias a las generosas licencias y el kit de desarrollo de controladores de SGI, vamos a ver más y más hardware OpenGL para usuarios de PC’s. Al contrario de Direct3D, OpenGL es un API altamente portable y sencilla . Lo de sencilla es más bien en comparación con Direct3D, ya que para poder comprender la mayor parte de las funciones de OpenGL es necesario tener un poco de conocimientos de Algebra Lineal, Geometría y un poco de 2
Delphi en tres dimensiones Física, aunque a final de cuentas no es tan difícil como puede parecer. OpenGL provee prácticamente las mismas funcionalidades en cuanto a capacidades gráficas que Direct3D; incluso en algunos aspectos se comporta de una manera más eficiente, y posee una serie de características que facilitan al programador la tarea de construir la escena, como tal es el caso de las Listas de Despliegue, que son una manera de almacenar comandos de dibujo en una lista para un trazado posterior. Los Programadores de Delphi tenemos un amplio panorama en frente nuestro respecto a OpenGL, ya que de por sí las versiones de Delphi de 32 bits incluyen la DLL OpenGL32, que es la versión de OpenGL para Win32, además incluye una unidad llamada OpenGL.Pas la cual es la interfaz entre la DLL y nuestras propias aplicaciones. Incluso algunas versiones de Delphi traen archivos de ayuda para esta API y sus múltiples funciones. Debemos mencionar que existen muchos programadores de Delphi que han hecho valiosas aportaciones al mundo de los gráficos, tales como: Mitchell E. James con su componente GLPanel, ó Mike Lischke, el cual es un prominente miembro del grupo JEDI ( Joint Endeavor of Delphi Innovators, Grupo de Esfuerzos de Innovadores de Delphi), y que también ha escrito varias librerías para OpenGL en Delphi. Esto, por mencionar solo a algunos, a fin de cuentas existen muchos programadores reconocidos en este ámbito.
permitiéndonos olvidarnos de las rutinas de rasterización por software. Pero también es claro que aparecerán más versiones de Direct3D, incorporando mejoras y que no saldrán nuevas versiones de OpenGL para Windows (al menos esa es la intención de Microsoft). Por otra parte tenemos los obscuros planes de Microsoft de lanzar una consola basada en Direct3D y Windows CE en conjunción con SEGA y de crear una nueva API trabajado conjuntamente con Silicon Graphics, que promete ser una fusión de ambas APIs. Por esto no debemos preocuparnos por un futuro lleno de conjeturas y ocuparnos por el presente. Nuestra recomendación (si de algo sirve para aquellos que después de leer esto quedaron aun más confundidos) es determinar el mercado de la aplicación que pretendemos realizar y el tiempo que se tiene para terminar el proyecto, de esta forma podremos decidir por una complicada API con mercado amplio en las PC’s como Direct3D; o bien una API sencilla con un mercado más restringido en las PC’s que nos permite la posibilidad de portar código a casi cualquier plataforma de una forma mas sencilla como tal es el caso de OpenGL. En posteriores números estudiaremos más a fondo cada una de estas API’s (OpenGL y Direct3D), y presentaremos algunos programas interesantes que podemos realizar con Delphi basándonos en estas tecnologías (como el mostrado en la figura 1), así como algunas cuestiones relacionadas con la representación virtual de objetos.
Figura 1. Un ejemplo de una Aplicación 3D hecha en Delphi Está claro que en un futuro cercano las tarjetas aceleradoras 3D usando tecnología OpenGL. de hardware reemplazarán por completo las actuales,
Otras consideraciones adicionales
Figura 1. 1. Un ejemplo de una Aplicación 3D hecha en Delphi usando tecnología OpenGL.
3
Introducción a la Programación de Gráficos con OpenGL Construcción de Aplicaciones Gráficas. Matrices y Vectores. Inicialización de Contextos y consideraciones adicionales. Bien, ahora nos dedicaremos a estudiar específicamente el API de gráficos OpenGL. En el articulo del número pasado hablábamos de las comparaciones entre OpenGL y Direct3D, y de lo que es un API de gráficos solo en teoría, pero esta vez estudiaremos más a detalle y con ejemplos de código como se construye una aplicación gráfica basada en OpenGL. Siendo honestos, la programación de gráficos 3D no es un tema sencillo, ya que requiere de conocimientos previos de análisis numérico, álgebra lineal, física y otros muchos temas extras, sin embargo aquí trataremos de hacer esto lo más digerible posible para que todo el mundo podamos entenderlo sin tanto embrollo; aunque desafortunadamente, no hay forma de evitar la necesidad de tener conocimientos sobre matrices, vectores, y un poco de geometría, así que más conviene dedicar algo de tiempo a estudiar estos temas si se quieren hacer este tipo de aplicaciones.
que esto ofrece independencia del sistema operativo, pues no es lo mismo crear una ventana basándose en las API’s de Windows que crear una ventana en algún ambiente gráfico de Unix o Linux, por esto, si se usa GLUT como manejador de ventanas, no se tendría que reescribir el código para migrar la aplicación de plataforma, ya que solo habría que conseguir la versión de GLUT para el ambiente gráfico deseado y volver a compilar nuestro programa en el nuevo ambiente. Esto debemos pensarlo los programadores de Delphi si deseamos usar OpenGL en la inminente nueva versión de Delphi para Linux. Las funciones contenidas en esta librería empiezan con las letras glut . Estas librerías se encuentran disponibles en Internet, y se distribuyen de manera gratuita en diferentes sitios, principalmente se pueden encontrar en el sitio oficial de OpenGL en http://www.opengl.org , donde seguramente encontrarán las de su sistema operativo en específico. Otro componente es el llamado Frame Buffer , que no es otra cosa que el área de memoria donde se construyen los gráficos antes de mostrarlos al usuario, es decir, que nuestro programa de OpenGL escribe en esta área de memoria, y automáticamente envía su contenido a la pantalla una vez que la escena está completamente construida. La figura 1 muestra gráficamente como esta constituida la estructura de abstracción de OpenGL.
¿Como Funciona OpenGL? OpenGL funciona a través de una serie de librerías DLL que suelen tener variados nombres, pero que a fin de cuentas cubren funciones muy específicas y son muy sencillas de identificar, ahora veremos cuales son estas: OpenGL.DLL (Open Graphics Library, Librería de Gráficos Abierta).- Esta podemos encontrarla también con el nombre de OpenGL32.DLL (para el caso de los sistemas operativos de 32 bits) o bien simplemente como GL.DLL . Esta es la librería principal, que contiene la mayoría de las funciones que aquí utilizaremos. Las funciones contenidas en esta librería inician con las letras gl. GLU.DLL (Graphics Utility Library, Librería de Utilerías de Gráficos).- También la podemos encontrar como GLU32.DLL. Contiene funciones para objetos comunes a dibujar como esferas, donas, cilindros, cubos, en fin, varias figuras ya predefinidas que pueden llegar a ser útiles en ciertos casos, así como funciones para el manejo de la cámara entre muchas otras. Podremos identificar las funciones que pertenecen a esta librería porque llevan antepuestas en su nombre las siglas glu. GLUT.DLL (GL Utility Toolkit, Equipo de Herramientas de Utilería para el desarrollo de Gráficos ).- Esta también permite crear objetos complejos como GLU, aunque la principal función de esta librería es permitir que los programas se vuelvan interactivos, o sea que posibilita la libre creación de ventanas, así como el acceso al ratón y al teclado. Nosotros podríamos llegar a prescindir en ese aspecto de GLUT, ya que Delphi nos ofrece de manera natural poder crear ventanas y responder a los diferentes eventos del manejo del ratón y el teclado; sin embargo, muchos programadores (principalmente programadores de C y C++) piensan que programar aplicaciones basadas en GLUT tiene muchísimas ventajas, ya
Figura 1 Niveles de Abstracción en OpenG OpenGL L
Las Piedras angulares: las matrices y los vectores Aquí es donde empieza el trabajo sucio de todo este asunto. Toda la geometría que se despliega en las aplicaciones OpenGL está basada en los conceptos de Matrices y Vectores y las operaciones aritméticas aplicables a estas estructuras. En OpenGL existen básicamente tres matrices principales: Una matriz de proyección llamada GL_PROJECTION, la cual nos permite determinar la perspectiva que usaremos para observar la escena generada, así como el tipo de proyección a usar (esto tiene que ver mucho con cuestiones de óptica y de geometría, y abordaremos este tema en otra ocasión más específicamente, ya que es bastante extenso y complejo). Esta matriz tiene una gran relación con otro concepto también muy interesante llamado clipping, que consiste en recortar u ocultar todo aquello que “está pero no se ve”, es decir lo que queda fuera del foco de nuestra cámara o nuestro campo visual activo, este es un proceso que se hace automáticamente una vez, habiendo 4
Introducción a la Programación de Gráficos con OpenGL inicializado pertinentemente esta matriz. Una matriz de Modelado llamada GL_MODELVIEW, donde ésta es la matriz que usaremos para aplicar a nuestra escena operaciones de rotación, traslación o escalamiento, o bien para manipular la posición y orientación de la cámara, para obtener así las animaciones. La figura 2 muestra algunos ejemplos de matrices de transformación lineal para el caso de sistemas de 3
de los vectores, y como se transforman las coordenadas hasta llegar a las coordenadas reales de la ventana.
Vectores de diversos tipos
Los vectores son un conjunto de valores que nos permiten definir dentro de nuestra escena, desde los vértices de las figuras, hasta los colores, los materiales y las luces, entre otras muchas cosas. Existen básicamente dos formas de trabajar con vectores en OpenGL, con sus elementos como variables independientes, o manejarlos como una estructura de datos. Cuando trabajamos sus elementos de forma independiente cada vector es descompuesto en 3 ó 4 valores según sea el caso. Y cuando se maneja como una estructura estos valores están contenidos en una estructura de datos que bien puede ser un arreglo ó un registro. Decimos que los vectores pueden descomponerse en 3 o 4 valores, ya que en el caso de los colores estos están compuestos por tres que determinan el color, codificados en RGB, y un elemento extra en algunos casos, que determina el nivel de transparencia para Figura 2. Matrices Genéricas de Transformación Lineal para Sistemas de 3 Dimensiones. dimensiones. Y una última matriz para el manejo de Texturas llamada GL_TEXTURE, sobre la cual también podemos aplicar las transformaciones lineales de rotación, traslación y escalamiento para manipular las texturas a utilizar en las figuras de nuestra escena, cuando estemos más avanzados explicaremos mas a detalle el manejo de texturas en nuestros programas, pero debemos aprender a gatear antes de intentar correr . Podemos hacer uso de cada una de estas matrices mediante el procedimiento GLMatrixMode(), el cual nos permite seleccionar una de estas matrices para su configuración. Para inicializar con valores cada matriz se invoca a un procedimiento llamado GLLoadIdentity(), el cual carga la matriz identidad, que es aquella que solo contiene valores de 1 en toda su diagonal (como se muestra en la figura 3), lo cual hace que multiplicar cualquier vector por esta matriz nos dé como resultado al mismo vector sin que haya sufrido ninguna transformación. Ahora tal vez Figura 4. Secuencia de Transformación de Coordenadas.
Tipos en OpenGL Figura 3. La Matriz Identidad se preguntarán “¿ y de cual hierba hay que fumar para saber como multiplicar vectores por matrices?”, pues basta con echar una mirada a cualquier libro de Álgebra Lineal y ahí se explica el oscuro procedimiento. En la figura 4 podemos observar el orden en como se aplican las matrices a cada uno
Debemos recordar que las librerías de OpenGL fueron escritas originalmente en C, así que conservan muchas características de este lenguaje, entre ellas, la estructura de sus procedimientos, y los tipos que se utilizan. Aunque en los tipos de OpenGL se anteponen las siglas GL, estos guardan una marcada equivalencia con los tipos genéricos de C, así GLFloat sería el equivalente al tipo float de C, y GLint, al tipo int . Y los rangos del dominio alcanzado por cada uno de estos tipos depende de su correspondiente equivalencia en C. Aunque OpenGL también provee de ciertos tipos de datos estructurados para el manejo tanto de matrices como de vectores, y generalmente estos tipos ya vienen en las librerías de OpenGL para Delphi con su respectiva equivalencia en tipos de Object Pascal.
5
Introducción a la Programación de Gráficos con OpenGL el objeto, cara ó vértice al cual corresponda dicho color, a esta característica de transparencia se le conoce comúnmente como Alpha Blending. Todos estos valores (en el caso específico de los colores) tienen un dominio que fluctúa en el rango de 0 a 1. Los vectores están compuestos por números que pueden ser de tipo real, enteros, bytes, doubles, short, etc... Aquí cabe señalar que OpenGL provee de sus propios tipos, los cuales por convencionalismos similares al que usamos en Delphi, anteponiendo una T a las clases que usamos, en OpenGL se antepone GL a la definición de Tipos que se utiliza, así por ejemplo GLFloat, es el equivalente del tipo Single en Delphi, y así existen muchas equivalencias entre ambas tipologias (Ver recuadro: Tipos en OpenGL). Para declarar un vector como un vértice descomponiendo sus elementos usaríamos la instrucción GLVertex3f(X,Y,Z) , donde X, Y y Z son variables ó constantes de tipo GLFloat, Real, ó Single. La parte final de la instrucción que usamos: 3f , nos indica que el procedimiento recibe como parámetro tres valores de punto flotante. Así la instrucción GLVertex3i() funcionará exactamente igual solo que con valores enteros. Cuando trabajamos los vectores como una estructura de datos lo que hacemos es pasar la dirección de memoria de esta estructura en la llamada del procedimiento, usando el operador @. Por ejemplo: Si suponemos una variable V de tipo Tvector, donde Tvector está definido como: Tvector = Array [0..2] of GLFloat; podríamos usar la instrucción: GLVertex3fv(@V); para declarar el vértice a partir de este dato estructurado. Observen como en estos casos las instrucciones para manejar estructuras terminan en: v.
¡En Delphi!, ¡En Delphi por favor! Bueno, ahora realizaremos nuestro primer programa OpenGL en Delphi, pero para esto, a fin de hacer las cosas mucho más sencillas y que no nos cueste tanto trabajo empezar, utilizaremos una adecuación a la librería OpenGL.Pas (versión 1.2) de Delphi hecha por Mike Lischke, un alemán con muchas aportaciones al mundo de los gráficos en Delphi, y que provee en esta librería muchas funciones que facilitan el proceso de inicialización de contextos, que nos permitirán entender este caso de una manera muy sencilla. Tanto el código fuente que aquí veremos, como las librerías .pas que utilicemos podrán descargarlas desde el sitio web de esta revista sin ningún problema. Primero que nada echemos un vistazo al Listado 1, y ahora analizaremos bit por bit este código fuente, ó al menos eso intentaremos. unit Unit1; interface uses Windows, Forms, OpenGL, Classes, ExtCtrls, Messages, Controls, StdCtrls,Graphics, sysUtils, Dialogs; type TForm1 = class(TForm) Timer1: TTimer; procedure FormCreate(Sender: TObject); procedure FormDestroy(Sender: TObject); procedure FormPaint(Sender: TObject); procedure FormResize(Sender: TObject); procedure Timer1Timer(Sender: TObject);
private { Private declarations } procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND; public { Public declarations } end; var Form1: TForm1; RC : HGLRC; Angulo : GLInt; implementation {$R *.DFM} procedure TForm1.FormCreate(Sender: TObject); begin RC:=CreateRenderingContext(canvas.Handle,[opDoubleBuffered],32,0); //Primero Creamos un contexto... end; procedure TForm1.FormDestroy(Sender: TObject); begin DestroyRenderingContext(RC); //Se libera el Contexto... end; procedure TForm1.FormPaint(Sender: TObject); Var X,Y,Z:GLInt; begin ActivateRenderingContext(canvas.Handle,RC); // Se asocia el contexto con el manejador del Canvas... glClearColor(0,0.2,0,0); // Ponemos un color Verde Oscuro de Fondo... glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); // Algo así como borrar la Pizarra... glMatrixMode(GL_MODELVIEW); glLoadIdentity; gluLookAt(0,0,3,0,0,0,0,1,0); // Posición y punto de vista de la cámara... glRotatef(30,1,0,0); //Primero hacemos una rotación de 30 grados respecto a X para obtener perspectiva... glRotatef(Angulo,0,1,0); //Se Rota la figura en el eje Y a partir de la variable Angulo... GLPointSize(2.0); //Asignamos un tamaño de 2 pixeles para cada punto... //Ahora con tres ciclos anidados dibujamos un cubo con puntos de colores variados... GLBegin(GL_POINTS); For x := -5 to 5 do for y := -5 to 5 do for z := -5 to 5 do begin GLColor3f(X,Y,Z); GLVertex3f(X/10,Y/10,Z/10); end; GLEnd; SwapBuffers(canvas.Handle); //Copiar el Back Buffer en el canvas del formulario... DeactivateRenderingContext; //Libera el contexto... end; procedure TForm1.FormResize(Sender: TObject); begin // Cuando se cambia de tamaño hay que actualizar el puerto de visión... wglMakeCurrent(canvas.handle,RC); // Otra manera de hacer el contexto dibujable cuando este ya está creado... glViewport(0,0,Width,Height); // Especificar un puerto de visión.... glMatrixMode(GL_PROJECTION); // Activar matriz de proyección... glLoadIdentity; // Poner estado inicial en esta matriz... gluPerspective(35,Width/Height,1,100); // Especificar Perspectiva ... wglMakeCurrent(0,0); // Otra manera de liberar el contexto... Refresh; // Redibujar la escena ... end;
6
Introducción a la Programación de Gráficos con OpenGL
procedure TForm1.Timer1Timer(Sender: TObject); begin Inc(Angulo,4); //Rotamos el angulo de observación de la escena... Angulo := Angulo mod 360; Refresh; //y la volvemos a dibujar ... end; procedure TForm1.WMEraseBkgnd(var Message: TWMEraseBkgnd); begin //Para borrar el fondo, y evitar el parpadeo ... Message.Result:=1; end; end.
Como podemos observar en el listado, tenemos un formulario y un componente Timer, el formulario nos servirá como la ventana en donde se mostrarán los gráficos; y el Timer será quien coordine nuestra animación, en esta ocasión a fin de hacer las cosas más sencillas usaremos el Timer para esta finalidad, pero ya veremos más adelante en artículos posteriores que es mucho mas eficiente utilizar hilos de ejecución de alta prioridad para hacer esto, por ahora dejémoslo de ese tamaño. Primeramente y como se deben de imaginar, necesitamos un lienzo en el cual plasmar nuestras “obras de arte”, por lo cual necesitamos de procesos que nos permitan acceder directamente a algún objeto gráfico que nos sirva como lienzo. En este primer ejemplo usamos el Objeto Canvas de nuestro formulario, pero en teoría podemos utilizar el Canvas de cualquier otra clase que contenga a éste objeto (un PaintBox por ejemplo). A este lienzo le llamaremos el contexto. Como pueden darse cuenta tenemos una variable global llamada RC de tipo HGLRC, esta variable será la que represente nuestro contexto dibujable. En el evento OnCreate del formulario hemos escrito una línea de código que sirve para asociar nuestro contexto con el manejador ( handle) del objeto Canvas del formulario, lo cual hace que nuestras animaciones se desplieguen sobre este Canvas. Los parámetros que se pasan a este procedimiento los estudiaremos a detalle en otra ocasión. Del mismo modo en el Evento OnDestroy del formulario debemos escribir una línea de código que libere nuestro contexto del Canvas, para evitar así apuntadores perdidos por ahí. Ahora, las animaciones como han de suponer deben construirse escena por escena, como en las películas de dibujos animados, con ligeras diferencias entre ellas para obtener calidad en nuestra animación, y a la vez debemos hacer uso de algún evento para mostrar estas escenas; así que podemos utilizar el evento OnPaint del formulario para irlas mostrando una por una. Como sabemos este evento se dispara cada vez que Windows tiene que dibujar el formulario así que podemos ocuparlo para que haga en él lo que nosotros deseamos que se vea. En este evento es donde escribimos el código para generar las escenas que nos interesa mostrar, vemos como con cada frame o escena, hacemos el contexto dibujable y al finalizar lo liberamos de nuevo. La instrucción glclearcolor() recibe como parámetro un vector de 4 valores que determinarán el color con el que se inicializará nuestro frame buffer antes de escribir en él, dando como resultado un color de fondo. La instrucción GLClear() sirve para borrar de este frame buffer valores de escenas que hayan sido construidas previamente a la actual. También podemos observar como hacemos uso de la matriz ModelView, y su
inicialización con GLLoadIdentity(), para poder aplicar las operaciones de rotación con las operaciones GLRotate() a los vértices que luego se definen. La operación gluLookAt() sirve para determinar un punto de observación (ó cámara) para la escena, podríamos obtener el mismo efecto de rotación si en vez de transformar los vértices de la escena solo movemos este punto de observación, es algo similar a lo que se hace en los clásicos juegos 3D de estilo Doom. En posteriores artículos hablaremos concretamente de la cámara y su utilización en concreto. Esta animación la construiremos utilizando solo puntos aislados, por lo que usamos la operación GLPointSize() para determinar el número de píxeles reales que ocupará cada uno de nuestros puntos, en nuestro caso 2. Y luego entre las declaraciones GLBegin() y GLEnd() que sirven para determinar los vértices de una figura, llamamos a GLColor3f() y GLVertex3f() dentro de tres ciclos anidados para dibujar todos los vértices con su correspondiente color. Nótese que se deben de declarar primero los colores que los vértices, porque como veremos más adelante, OpenGL funciona como una máquina de estados finitos, donde se deben declarar los atributos antes de las figuras.
¿Y el resto? Hasta ahora ya utilizamos la matriz de modelado para hacer las rotaciones, pero como vemos en el evento OnResize hacemos uso de la matriz de proyección para definir nuestro puerto de visión y perspectiva. Entender como funciona realmente la matriz de proyección es un poco complicado y ya la estudiaremos a su tiempo, por ahora solo debemos entender que el evento OnResize se dispara cada vez que modificamos el tamaño de nuestra ventana, por lo cual debemos ajustar la escala de lo que estamos observando para no perder las dimensiones, es por eso que debemos tenerlo presente. Observen como al final del código para este evento usamos el método Refresh del TForm, lo cual obliga al formulario a volver a dibujar la escena con la matriz de proyección ya ajustada. También cuando Windows trata de dibujar el formulario después de haberlo creado se dispara OnResize, lo que nos garantiza que, desde el principio, tendremos ajustada nuestra perspectiva sin la necesidad de modificar nosotros mismos el tamaño de nuestra ventana. Una vez ejecutando este programa traten de modificar el tamaño ustedes mismos para que vean como es que funciona esto. El procedimiento del Timer lo único que hace es incrementar una variable global llamada Angulo y volver a dibujar la escena; la operación mod que efectuamos a esta variable es para asegurarnos que su dominio solo fluctuará entre los valores 0 y 359, que son los 360 grados de una circunferencia. Nosotros en el evento OnPaint rotamos la escena conforme a esta variable, lo que ocasiona que escena con escena obtengamos nuestra figura en diferentes posiciones relativas, y con esto obtener la animación. El numero de unidades que incrementemos a esta variable con cada escena, será lo que determine la calidad de nuestra animación a final de cuentas. Ahora como estamos utilizando el Canvas del formulario como lienzo y continuamente estamos mandando a redibujar la escena, forzamos a que Windows tenga que borrar el contenido del formulario anterior antes de mostrar el nuevo contenido, lo cual ocasiona un continuo parpadeo en nuestra animación, cosa 7
Introducción a la Programación de Gráficos con OpenGL que no es nada deseable. Por esto lo que tenemos que hacer es evitar que Windows se tome esta molestia, de cualquier modo nosotros mismos estamos dibujando sobre esta ventana lo que se nos va antojando, así que para que perder ese valioso tiempo. Para evitar que Windows borre el contenido del formulario debemos utilizar un manejador de mensajes que opere para el mensaje WM_ERASEBKGND, el cual es enviado por Windows cada que se necesita borrar el fondo de una ventana, para evitar que Windows tome alguna acción, sólo debemos devolver como resultado un valor distinto de 0 para indicar que nosotros mismos haremos ese trabajo (en nuestro caso devolvemos un 1). Los manejadores de mensajes en este tipo de aplicaciones suelen ser bastante útiles, ya veremos después como responder a cambios en la paleta de colores y en la resolución de la pantalla por citar algunos casos. Y con esto es suficiente para poder compilar y observar nuestra primera animación con OpenGL (Figura 5),
hace por Software, así que no se quejen si en su equipo las animaciones se ven demasiado lentas, lo más seguro es que su Hardware sea el culpable. Bueno, hasta aquí llegamos en esta ocasión, porque parece que tenemos suficiente con que entretenernos por ahora, y todavía mucho por estudiar en el futuro... Hasta Pronto.
Figura 5. Nuestra Primera Aplicación de OpenGL en Ejecución. sorprendente ¿verdad?, con muy pocas líneas de código hemos conseguido grandes resultados, como ya es costumbre con los programas que hacemos con Delphi. Ahora algunas consideraciones extras: Por alguna extraña razón las aplicaciones que hacemos con Delphi usando OpenGL ocasionan un conflicto cuando las ejecutamos desde el IDE, por lo cual es recomendable solo compilarlas y ejecutarlas desde fuera del Ambiente de Desarrollo Integrado. Y una cosa más, recordemos que OpenGL utiliza aceleración por Hardware para optimizar el renderizado de las escenas, pero cuando el nuestro no provee esas características de aceleración, todo lo que debería de hacerse por Hardware se 8
Líneas con OpenGL en dos dimensiones Proyección Ortogonal 2D. Construcción de gráficos con Líneas. Antializado. Algoritmos recursivos de Fractales. OpenGL no se utiliza solamente para generar impresionantes gráficos 3D, sino como veremos a continuación también puede utilizarse para hacer gráficas en 2 dimensiones. En esta ocasión trabajaremos con los diferentes tipos de líneas que nos ofrece OpenGL; y a fin de hacer este tema todavía mas interesante veremos un extra bastante útil e impresionante: Los Fractales, un concepto matemático muy utilizado en la graficación por computadora.
Visualización 2D Aunque aquí tratemos el tema de la visualización 2D en OpenGL, es importante recordar que este es un API gráfico de 3 dimensiones; así que si queremos utilizarlo para hacer representaciones 2D tenemos que hacer un pequeño truco. Como ustedes han de suponer lo que hemos de hacer es graficar todo lo que deseemos en un plano, para obtener así la apariencia de que estamos trabajando con 2 dimensiones aunque realmente sigamos trabajando en 3. Entonces la visualización 2D se basa en tomar un área rectangular de nuestro mundo 3D y transferir su contenido a nuestro despliegue. El rectángulo de visualización está en el plano z=0. Por default si no se específica el volumen de visualización se construye un rectángulo de 2x2, donde las coordenadas de este rectángulo quedan como: ((-1.0,-1.0),(1.0,1.0),(1.0,-1.0),(1.0,1.0)), estas coordenadas, claro, en el plano z=0.
Figura 1
En este caso cualquier coordenada que definamos como (x,y,z), será proyectada sobre el plano de visualización z=0 como (x,y,0), y si esta coordenada entra dentro de nuestro rectángulo será mostrada en nuestro despliegue (ver figura 1). Si es nuestra intención modificar las coordenadas de nuestro rectángulo de visualización debemos definirlas mediante la instrucción glOrtho2D(), con la cual declaramos los valores de 2 coordenadas que determinarán el área del rectángulo, es decir, la esquina superior izquierda y la inferior derecha.
¿Qué son los Fractales? Para comprender lo que es un fractal, hagamos un pequeño ejercicio: tomemos una hoja de papel y dibujemos sobre ella un segmento rectilíneo. La geometría Euclidiana nos dice que se trata de una recta y por tanto tiene una sola dimensión (su longitud). Ahora extendamos el segmento rectilíneo haciendo trazos de un lado a otro sin que éstos se crucen hasta llenar toda la hoja. La geometría Euclidiana nos dice que todavía se trata de una línea y que tiene una sola dimensión, pero nuestra intuición nos dice que si la línea llena completamente el plano debe tener más de una dimensión, si bien no llegará a tener dos. Esto implica que nuestro dibujo debe tener una dimensión fraccionaria. Este concepto tan simple comenzó toda una revolución en las matemáticas. Varios matemáticos de fines del siglo XIX y principios del XX propusieron la existencia de una dimensión fraccionaria y no debiera sorprendernos que sus colegas los tildaran de locos, pues esa idea aparentemente tan aberrante atentaba contra la noción de dimensiones enteras que todos conocemos. Hubieron de pasar cerca de 50 años para que un matemático se tomara en serio tan aventuradas teorías. En 1975 el Dr. Benoît Mandelbrot, acuñó un nombre para estas figuras que tienen una dimensión fraccionaria. Las llamó fractales, término que derivó del adjetivo latino fractus, que significa "irregular " o "interrumpido". Mandelbrot afirma que así como las figuras geométricas convencionales son la forma natural de representar objetos hechos por el hombre (cuadrados, círculos, triángulos, etc.), los fractales son la forma de representar objetos que existen en la Naturaleza. De tal forma, los fractales tienen una doble importancia: como objetos artísticos (por poseer una singular belleza) y como medio para representar escenarios naturales. Es más, los fractales están presentes en las expresiones utilizadas para describir fenómenos tan variados como la predicción del clima, el flujo turbulento de un líquido, el crecimiento o decrecimiento de una población y, hasta para comprimir imágenes. La idea principal detrás de los fractales es que algunas imágenes pueden ser producidas repitiendo una fracción de sí mismas. Tomemos como ejemplo un árbol: si observamos una de sus ramas, caeremos en la cuenta de que asemeja un árbol en pequeño. Valiéndonos de esta curiosa propiedad (llamada auto-similitud o "self-similarity" en inglés) puede dibujarse una figura compleja repitiendo una imagen mucho más simple. A esta repetición se le llama recursividad . Llevando la recursión a niveles más elevados llegaremos al concepto de Sistemas de Funciones Iteradas o IFS (por sus 9
Líneas con OpenGL en dos dimensiones siglas en inglés): tomemos un punto y movámoslo por la pantalla, trasladémoslo, rotémoslo y ajustemos su escala aleatoriamente. Esto nos permitirá obtener imágenes relativamente complejas a partir de patrones sumamente simples, si iteramos un número adecuado de veces. Todos estos conceptos aunque de entrada parezcan complejos, veremos que su aplicación no lo es tanto y cómo podemos nosotros usar fractales para representar todo un paisaje, con objetos de la naturaleza de una manera muy sencilla y simple.
Tipos de Lineas en OpenGL Existen básicamente 3 tipos de líneas en OpenGL: Líneas sencillas, Líneas en ciclo y Líneas con patrones. Como habíamos visto en el número anterior la definición de figuras en OpenGL se hace con las instrucciones GLBegin() y GLEnd(), donde a GLBegin() se le pasa como parámetro el tipo de figura que nos interesa dibujar con los vértices definidos entre estas instrucciones (el ejemplo pasado lo hicimos solo con puntos usando GL_POINTS), así que ahora estudiaremos como hacer líneas con ellas. Para hacer líneas sencillas usamos GL_LINES, con esta instrucción como parámetro para GLBegin() indicamos a OpenGL que dibuje una línea que una cada dos vértices que nosotros definamos. Algo muy similar a cuando trabajábamos con el Objeto Canvas y usábamos las instrucciones MoveTo(x,y) y LineTo(x,y), ¿lo recuerdan?... ¡ah... que tiempos aquellos! ... Las líneas en ciclo nos sirven para definir contornos. Para hacer este tipo de líneas usamos GL_LINE_LOOP, cuando utilizamos esta instrucción unimos todos los vértices que definimos con una misma línea en el orden en que hayan sido estos definidos, y al mismo tiempo se unen el último vértice definido con el primero, cerrando así la figura. Esto es muy útil para dibujar contornos de polígonos (ya sean regulares o irregulares), por ejemplo. ¿Recuerdan cuando trabajábamos con el Canvas que podíamos cambiar el estilo de la pluma para dibujar líneas punteadas o con diversos patrones?. Pues en OpenGL también se pueden declarar varios patrones para dibujar líneas. Para ello usamos en nuestro ejemplo la instrucción GL_LINE_STRIP como parámetro, éste permite escribir una secuencia de líneas unidas vértice a vértice, pero a diferencia de GL_LINE_LOOP el último vértice no se une con el primero. Ya veremos sobre la marcha como declaramos los patrones a utilizar.
Calidad en el trazado de líneas También, como en el número anterior vimos la instrucción GLPointSize() para hacer más grande el tamaño de los puntos que dibujamos, en el caso de las líneas podemos hacer que OpenGL las dibuje más gruesas de cómo las presenta originalmente con la instrucción glLineWidth() , pasándole como parámetro un número entero que indique el número de pixeles que ocupará el ancho de las líneas a dibujar. Volviendo a los añejos recuerdos del Canvas... ¿Recuerdan como cuando dibujábamos líneas con cierto ángulo diagonal, se dibujaban en forma de escalerita?; esto se debe en gran medida a que los algoritmos clásicos de trazado de líneas como el método de Bresenham ó el del DDA ( Análisis Diferencial
Digital) entre otros, se limitan solo a encontrar aquellos pixeles que puedan representar a la línea en cuestión, pero no se ocupan de la presentación que esta tendrá para el usuario. En OpenGL existe un concepto muy interesante al respecto llamado antialiazing o antializado. El antializado consiste precisamente en eliminar esos escalonamientos que se presentan tanto en las líneas como en los contornos de las figuras a representar para obtener así figuras más realistas, que no se vean tan “ poligonales”. En esta ocasión estudiaremos el antializado en cuanto a líneas.
¡Vamos al Código! Bueno, vamos directamente al ejemplo que aquí presentamos. Echemos una mirada al Listado 1, y a ver que podemos aprender de esto. Por ahora pasemos por alto los procedimientos que hemos definido para dibujar los fractales y centrémonos en los eventos de los objetos. Como pueden darse cuenta la estructura de este programa es muy similar a la del programa que estudiamos en el número anterior, ya que seguimos usando la misma versión de OpenGL.Pas, y el método de inicialización de contextos no cambia para nada. Las diferencias las empezamos a encontrar en el evento OnPaint(). Como vemos en la instrucción GLClear(), solo pasamos como parámetro el Buffer de Color (GL_COLOR_BUFFER_BIT) y ya no el buffer de profundidad (GL_DEPTH_BUFFER_BIT) como en el ejemplo pasado; la razón es que ahora sólo trabajaremos en 2 dimensiones, así que no hay relación de profundidad entre las figuras que dibujaremos, por lo que no necesitamos limpiar este buffer. Luego encontramos la instrucción gluOrtho2D (-1.0, 1.0, 0.0, 1.5); con la que definimos un rectángulo de visualización cuya esquina superior izquierda es (-1.0,1.5) y la esquina inferior derecha es (1.0,0.0). Ahora aquí vienen unas instrucciones que tal vez les resulten nuevas en este momento glPushMatrix() y glPopMatrix(). Suponemos que todos aquí hemos trabajado alguna vez con estructuras de datos de tipo Pila, y que entendemos los procedimientos de inserción y eliminación de elementos de esta estructura. Bueno, pues estas instrucciones trabajan con una pila de matrices y sirven para hacer respaldos de la matriz de transformaciones que luego podemos recuperar. La finalidad de hacer estos respaldos es para poder hacer ciertas transformaciones sobre figuras específicas sin que éstas afecten al resto de las figuras en nuestra escena. Esto es verdaderamente útil como veremos más adelante. Delimitemos ahora lo que pretendemos realizar con este código. Bien, pues lo que dibujaremos es: “un paisaje en el campo durante una noche de Eclipse de Luna ”, ¿qué les parece?, no me negarán que es un título bastante artístico para nuestra “obra de arte”; y todo usando solo líneas. Nuestro paisaje estará compuesto por árboles, estrellas, y la luna eclipsada, por supuesto. Así que necesitamos procedimientos que dibujen cada una de estas figuras. Tanto los árboles como las estrellas las construiremos usando fractales con procedimientos recursivos. Los fractales que usaremos serán del tipo de los sistemas S>eS*, lo que significa que serán sistemas que contendrán 10
Líneas con OpenGL en dos dimensiones elementos y a la vez a alguno ó algunos subsistemas similares. En nuestro caso, los elementos serán Líneas y los subsistemas serán llamadas recursivas al mismo procedimiento. Basándonos en este tipo de sistemas podemos construir diversos tipos de figuras de la naturaleza, como árboles, estrellas, piedras, nubes, e incluso podríamos llegar a representar el sistema solar. Analicemos primeramente el procedimiento para construir árboles. La llamada a este procedimiento tiene los siguientes parámetros: Arbol(x,y,t,teta,w:real); la idea con este procedimiento es dibujar a partir del punto ( x,y), un segmento de línea de longitud t e inclinación teta. Y después volver a llamar recursivamente a este procedimiento, pasando como parámetros el extremo final del segmento de recta generado y los parámetros t y teta con valores modificados para hacer simétrica la figura. A fin de cuentas lo que hacemos es dibujar un arbolito más pequeño al final de cada segmento de recta. Observen como ahora utilizamos glVertex2f() para declarar nuestros vértices ya que trabajamos en dos dimensiones. El parámetro w nos servirá para determinar el tipo de árbol que deseamos dibujar, pues como veremos, este simple procedimiento nos permite dibujar Cipreses, Jacarandas y Pinos. ¿ A poco no es sorprendente ?. Algo similar pasa con el procedimiento para dibujar las estrellas, solo que aquí todos los segmentos de recta tienen un mismo origen, el centro de la estrella. Así que lo que variamos es el ángulo de inclinación de cada segmento para obtener así la figura final.
Un detalle más: hemos puesto el trazado de la línea punteada entre dos sentencias de push y pop de atributos. ¿Recuerdan cuando en el artículo del número anterior dijimos que OpenGL es una máquina de estados?, en futuros artículos veremos con más detalle estas operaciones de push y pop para el caso de los atributos, pero brevemente lo que estamos haciendo con la primera sentencia glPushAttrib(GL_LINE_BIT) es guardar en una pila el valor actual de la variable de estado GL_LINE_BIT (esta variable decide el patrón de punteado), entonces podemos modificar GL_LINE_BIT con nuestra sentencia glLineStipple() y cuando hemos acabado llamamos a glPopAttrib() que devuelve el valor antiguo de la variable GL_LINE_BIT. Este mecanismo es una manera efectiva de modificar las variables de estado de OpenGL localmente. Si no lo hacemos así entonces todas las líneas dibujadas después de glLineStipple() tendrían el mismo patrón de punteado y estaríamos forzados a declarar un patrón con glLineStipple() para cada línea que trazásemos en nuestra aplicación. Push y pop nos evitan este molesto trabajo.
¿Y la luna y el antializado? Bien, pues la luna la construiremos como si fuera un polígono con GL_LINE_LOOP, recuerden que a final de cuentas un circulo podemos definirlo como un polígono que tiene muchos lados, tantos que no se llegan a distinguir. En nuestro caso hacemos uno de 100 lados. Como lo que pretendemos es dibujar una
Las líneas punteadas Siguiendo con el análisis sobre el procedimiento Star(), que dibuja las estrellas, vemos que aquí es donde usamos los patrones con las líneas. La función glLineStipple() especifica el patrón usado para el punteado, por ejemplo, si usáramos el patrón $AAAA (este es un número en hexadecimal), en binario este número es 1000100010001000, OpenGL interpreta esto dibujando 3 bits apagados, 1 bit encendido, 3 bits apagados, 1 bit encendido, 3 bits apagados, 1 bit encendido y por último 3 bits apagados y 1 encendido. El patrón se lee hacia atrás porque los bits de menor orden se usan primero. GlLineStipple() tiene dos parámetros, el patrón de punteado que debe ser un número hexadecimal y un factor entero que sirve para escalar este patrón; con un factor de 3 nuestra línea punteada mostraría 9 bits apagados, 3 bits encendidos, 9 bits apagados, 3 bits encendidos, 9 bits apagados, 3 bits encendidos y por último 9 bits apagados y 3 bits encendidos. Jugando con factores y patrones binarios, uno puede dibujar todo tipo de líneas punteadas complicadas. En nuestro ejemplo usamos el patrón $5555, con un factor de 1, lo que nos da un patrón uniforme de 1 pixel apagado por 1 encendido. ¡Hagan cuentas!.
Figura 2 luna eclipsada , entonces solo debemos preocuparnos de dibujar el contorno de esta luna, y aprovechamos que el color con el que borramos la pizarra es el negro para evitar dibujar el resto. Ahora, como decíamos, dibujar tantas líneas en tan diferentes ángulos ocasiona que nuestro circulo no luzca bien definido, por lo que aquí si es conveniente utilizar el antializado. El antializado para el caso de las líneas se habilita con la instrucción glEnable(GL_LINE_SMOOTH); y se inhibe con 11
Líneas con OpenGL en dos dimensiones tglDisable(GL_LINE_SMOOTH); Lo inhabilitamos porque no nos árboles pequeños, como es que se transforman las figuras
interesa dibujar toda nuestra escena con antializado, si no solo fractales para generar los diferentes tipos de árboles que la luna. Pueden probar que sucede cuando ignoran estas líneas tenemos en nuestra escena, modificando el parámetro w que habíamos mencionado. Estas animaciones están controladas de código, ya verán que así no parece luna. nuevamente por un componente Timer. Por ahora eso es todo, ya tenemos nuestra escena construida Para terminar un poco de animación (Ver Figura 2); que se diviertan experimentando con las líneas Por último, puesto que ya hemos utilizado los diferentes tipos y los fractales . Recuerden que pueden descargar el código de líneas disponibles en OpenGL, vamos a agregar un poco de fuente de este programa y las unidades extras que utilizamos animación a nuestra escena. Si mal no recordamos las estrellas directamente desde el sitio web de la revista. Hasta Pronto... “titilan”, por lo que usamos una variable para simular este efecto, así como una variable adicional para mostrar con 2
unit Unit1; interface uses Windows, Forms, OpenGL, Classes, ExtCtrls, Messages, Controls, StdCtrls,Graphics, sysUtils, Dialogs; type TForm1 = class(TForm) Timer1: TTimer; procedure FormCreate(Sender: TObject); procedure FormDestroy(Sender: TObject); procedure FormPaint(Sender: TObject); procedure FormResize(Sender: TObject); procedure Timer1Timer(Sender: TObject); private { Private declarations } procedure WMEraseBkgnd(var Message: TWMEraseBkgnd); message WM_ERASEBKGND; public { Public declarations } end; var Form1: TForm1; RC : HGLRC; Angulo : GLInt; Radio : GLFloat = 0; implementation {$R *.DFM}
procedure Arbol(x,y,t,teta,w:real); var x1,y1,t1:real; begin if t > 0.01 then {condición de paro} begin glbegin(GL_LINES); glVertex2f(x,y); x1 := x -t * cos(teta); y1 := y -t * sin(teta); glVertex2f(x1,y1); glend; t1 := t /1.7; {Se llama recursivamente al sistema} Arbol(x1,y1,t1,teta-w,w); Arbol(x1,y1,t1,teta,w); Arbol(x1,y1,t1,teta+w,w); end; end;
12
Líneas con OpenGL en dos dimensiones
Procedure Star(X,Y,t,Teta:Real); var X1,Y1:real; begin if Teta < 10 then {Nuestra condición de paro} begin glEnable (GL_LINE_STIPPLE); //Habilitamos el uso de los patrones... glPushAttrib (GL_LINE_BIT); //Salvamos el estado de las lineas... glLineStipple (1, $5555); //Declaramos el patrón a utilizar... glbegin(GL_LINE_STRIP); glVertex2f(x,y); //Todas las lineas tienen el mismo centro... x1 := x -t * cos(teta); y1 := y -t * sin(teta); glVertex2f(x1,y1); glend; glPopAttrib (); //Recuperamos el estado anterior... {Llamamos recusivamente al sistema} Star(X,Y,t,Teta+0.25); glDisable (GL_LINE_STIPPLE); //Inhibimos los patrones... end; end; Procedure Luna; var i:integer; Coseno,Seno:GLFloat; begin GLBegin(GL_LINE_LOOP); For i := 0 to 100 do begin Coseno := Cos(i*2*PI/100); Seno := Sin(i*2*PI/100); GLVertex2f(Coseno,Seno); end; GLEnd; end; procedure TForm1.FormCreate(Sender: TObject); begin RC:=CreateRenderingContext(canvas.Handle,[opDoubleBuffered],32,0); //Primero Creamos un contexto... end; procedure TForm1.FormDestroy(Sender: TObject); begin DestroyRenderingContext(RC); //Se libera el Contexto... end; procedure TForm1.FormPaint(Sender: TObject); begin ActivateRenderingContext(canvas.Handle,RC); // Se asocia el contexto con el manejador del Canvas... glClearColor(0,0,0,0); // Ponemos un color Verde Oscuro de Fondo... glClear(GL_COLOR_BUFFER_BIT); // Algo así como borrar la Pizarra... glMatrixMode(GL_MODELVIEW); glLoadIdentity; gluOrtho2D (-1.0, 1.0, 0.0, 1.5); //Para trabajar en 2 dimensiones... {Dibujamos algunos arbolitos felices...} glPushMatrix(); //Salvamos la matriz del ambiente... glLineWidth (1); glcolor3f(0,0,1); glrotatef(270,0,0,1); //Se incorporan los arboles... Arbol(0,0,0.3,0,0.5); Arbol(0,0.2,0.2,0,0.25); Arbol(0,-0.15,0.15,0,radio); Arbol(0,-0.65,0.25,0,2.1);
13
Líneas con OpenGL en dos dimensiones Arbol(0,0.5,0.2,0,radio); Arbol(0,0.7,0.35,0,0.55); Arbol(0,0.85,0.18,0,0.25); glPopMatrix(); //Recuperamos el ambiente... {Ponemos algunas estrellitas Felices...} glpushmatrix(); glLineWidth (1); glscalef(0.5,0.5,0); GlColor3f(0.5,1,0); Star(0.4,2,0.2*sin(Angulo),0); GlColor3f(1,1,0); Star(0.8,2.25,0.2*sin(Angulo),0); GlColor3f(1,0,0); Star(-0.3,2.4,0.2*sin(Angulo),0); GlColor3f(1,1,1); Star(1.5,2.4,0.2*sin(Angulo),0); glpopmatrix(); GLPushMatrix; glEnable (GL_LINE_SMOOTH); //Habilitamos el Antializado para las Lineas glLineWidth (5); //Modificamos el ancho de las lineas... GLColor3f(1,1,1); GLScalef(0.15,0.15,0); GLTranslatef(-4,7,0); LUNA; glDisable (GL_LINE_SMOOTH); //inhibimos el antializado... GLPopMatrix; SwapBuffers(canvas.Handle); //Copiar el Back Buffer en el canvas del formulario... DeactivateRenderingContext; //Libera el contexto... radio := radio - 0.03; //Variamos la variable radio if radio <= -6.3 then radio := 0; //para animar los arbolitos... end; procedure TForm1.FormResize(Sender: TObject); begin // Cuando se cambia de tamaño hay que actualizar el puerto de visión... wglMakeCurrent(canvas.handle,RC); // Otra manera de hacer el contexto dibujable cuando este ya está creado... glViewport(0,0,Width,Height); // Especificar un puerto de visión.... glMatrixMode(GL_PROJECTION); // Activar matriz de proyección... glLoadIdentity; // Poner estado inicial en esta matriz... wglMakeCurrent(0,0); // Otra manera de liberar el contexto... Refresh; // Redibujar la escena ... end;
procedure TForm1.Timer1Timer(Sender: TObject); begin Inc(Angulo,4); //Rotamos el angulo... Angulo := Angulo mod 365; Refresh; //y volvemos a dibujar la escena... end; procedure TForm1.WMEraseBkgnd(var Message: TWMEraseBkgnd); begin //Para borrar el fondo, y evitar el parpadeo ... Message.Result:=1; end; end.
14
escalar a partir de la multiplicación de 2 vectores. Las matrices por su parte pueden ser multiplicadas por otras matrices o por vectores. En el caso de la multiplicación de matrices con matrices, el procedimiento es relativamente sencillo: lo único que hay que hacer es multiplicar cada uno de Las transformaciones lineales, aunque los respectivos renglones y columnas de los argumentos como pudieran parecer un concepto un poco se muestra en la Figura 2, obteniendo los valores escalares de oscuro, no lo son tanto, y son la base para estas multiplicaciones de vectores, es decir que cuando poder generar animaciones con API’s multiplicamos una matriz por otra matriz, lo que obtenemos es una nueva matriz formada por estos valores escalares. Ahora gráficas. solo hay que tener en cuenta que las dimensiones de ambos argumentos deben de corresponder para poder hacer esta Bien, esta vez abordaremos el tema de las transformaciones operación, es decir que el número de columnas de la primera lineales; ciertamente es un tanto difícil hablar de términos matriz corresponda con el número de renglones de la segunda, matemáticos y de geometría de manera coloquial, sin embargo ¿Lo ven?, de otro modo no se podrían hacer las operaciones aquí trataremos de hacerlo lo más ligero posible para que todos sobre los vectores. nos enteremos, aunque de cualquier modo es recomendable Y para multiplicar matrices por vectores lo que hacemos es que cualquiera que se vea interesado en estos temas profundice tratar el vector en forma de renglón y multiplicarlo por cada en los libros de Álgebra Lineal, donde muchas dudas una de las columnas de la matriz, como se muestra en la figura 3. Así que aquí podemos apreciar que al multiplicar un vector seguramente serán resueltas (¿o tal vez ampliadas?).
Transformaciones Lineales en OpenGL
Empecemos con la teoría... Bueno, creo que deberemos empezar explicando el escabroso Figura 3. Multiplicación de un Vector por una matriz procedimiento mediante el cual se aplican operaciones sobre matrices por una matriz, lo que obtenemos es un nuevo vector y vectores.¿Recuerdan cuando hace algunos meses hablábamos “transformado”. de que toda la geometría que se despliega en las aplicaciones de OpenGL está basada en los conceptos de Matrices y Bueno, ¿y eso qué? Vectores y las operaciones aritméticas aplicables a estas estructuras?, bien, pues ahora vamos a sumergirnos un poco en Ahora, a nosotros lo que nos interesa es multiplicar vectores de 3 valores por matrices de 3*3 para obtener las lo que respecta a estas operaciones. Primeramente vamos a entender una matriz como una tabla transformaciones en tres dimensiones. Recordemos un articulo que contiene valores, y a un vector como un caso especial que pasado donde mostrábamos las diferentes matrices de puede representar un renglón o una columna de dicha tabla. transformación lineal para sistemas de 3 dimensiones, así en la Cuando multiplicamos un vector renglón por un vector figura 4 podemos ver como podemos obtener vectores columna lo que obtenemos es un valor al cual le llamamos transformados a partir de la multiplicación del vector original “escalar”. La Figura 1 muestra como obtenemos el valor por las matrices de Traslación y Escalamiento, haciendo un resumen de las operaciones necesarias para esto. Como aparece en la figura, hemos agregado un elemento extra tanto al vector como a la matriz, para poder tener una matriz “cuadrada” de 4*4, esto porque las matrices de transformación para sistemas de 3 dimensiones son de este tamaño, y por lo tanto necesitamos ajustar el vector de coordenadas con un Figura 1. Multiplicación de un Vector por otro vector valor extra, pero este valor en realidad no altera en nada el resultado sobre el vector transformado. La principal ventaja que tenemos de usar las matrices de transformación, es que si deseamos aplicar diferentes transformaciones a un mismo vector podemos multiplicar antes las matrices correspondientes, y después obtener el producto por el vector de la siguiente manera: | X'| = (| X |*| A |) *| B | puede aplicarse también como: Figura 2. Multiplicación de una matriz por otra matriz 15
Transformaciones Lineales en OpenGL
Figura 4. Matrices de rotación y escalamiento por vectores
Figura 6. Rotación de un cuerpo
| X'| = | X |* ( | A |*| B | )
transformación tanto de Donde X’ representa al vector transformado, X al vector T r a s l a c i ó n , original, y A y B son R o t a c i ó n , 2 matrices de Escalamiento y t r a n s f o r m a c i ó n Reflexión. distintas. Ahora, el orden Y si en el caso en como se anterior tomamos: apliquen estas operaciones | K | = | A |*| B | importa y mucho...Como entonces podemos bien sabemos en Figura 7. Escalamiento de un cuerpo sustituir K en la la aritmética segunda expresión común la multiplicación tiene la propiedad conmutativa, es como: decir, que el orden de los factores no altera el producto; sin embargo, en cuanto a la multiplicación de matrices de | X'| = | X |*| K | transformación lineal, no se aplica esta propiedad. Así que obtendremos diferentes resultados dependiendo de ¿Lo ven?... Podemos cual transformación apliquemos primero. La figura 8 muestra aplicar primero todas claramente los efectos obtenidos de aplicar las Figura 5. Traslación de un cuerpo las transformaciones a una sola matriz, y luego multiplicar por esta a todos los vectores o vértices que forman nuestra figura, y así tener más claro el procedimiento; bien, pues esta es la filosofía que se sigue en el modelado con OpenGL. Todas las transformaciones que definimos, lo hacen en la matriz de modelado (GlModelView) y se aplican a Rotación-Traslación Traslación-Rotación cada uno de los vértices que nosotros definimos con glvertex...(); ¿No es tan Figura 8. Diferencias en el orden de la aplicación de las transformaciones complicado o si? Las figuras 5 a la 7 muestran gráficamente los efectos que se transformaciones de Rotación y Traslación a un mismo ocasionan sobre un cuerpo al aplicarle las matrices de cuerpo en diferente orden. Y como podemos observar son 16
Transformaciones Lineales en OpenGL bastante distintas.
¿Y como representamos las transformaciones en OpenGL? Bien, una vez que nosotros definimos que usaremos una determinada matriz, ya sea la de modelado, la de proyección ó la de Texturas, podemos inicializarla usando la operación glLoadIdentity(); la cual carga la matriz identidad en ella. Donde tenemos que la matriz identidad ejerce ninguna modificación cuando multiplicamos un vector por ella, es decir que si I es una matriz identidad y V es un vector cualquiera tenemos que: |V| * |I| = |V|
Figura 9. Algunas primitivas de graficación en OpenGL
Las rotaciones se definen con la operación glRotate...(); la cual recibe 4 parámetros, el primero es el número de grados que nos interesa rotar el cuerpo o la escena, y los otros 3 determinan el nivel en que se verá afectada la operación respecto a cada uno de los 3 ejes X, Y y Z. Por ejemplo, si nos interesara hacer una rotación de 30 grados solo sobre el eje X, pasaríamos un 30 en el primer parámetro, un 1 en el segundo, y 0’s en los restantes. La operación de Traslación se define con glTranslate...(); esta recibe 3 parámetros, que son el número de unidades que deseamos trasladar la figura en cada uno de los 3 ejes. También podemos pasar como parámetros valores negativos, y así obtener traslaciones en sentidos contrarios. Y el escalamiento se define con glScale...(); este también recibe 3 parámetros que definen el grado de escalamiento que deseamos aplicar a cada uno de los 3 ejes. Si en este caso usamos glScalef(); podemos pasar valores fraccionarios como parámetros y poder así hacer escalamientos más exactos. Recordemos que las operaciones deben aplicarse antes de la definición de los vértices de las figuras que se verán afectadas por estas transformaciones, para que así estos vectores sean multiplicados por esta matriz ya definida. Si deseamos aplicar una transformación solo a un determinado cuerpo de nuestra escena, debemos definir primero las trasformaciones que afectarán a toda la escena y los vértices que no se verán afectados por la transformación nueva, y luego salvar la matriz en una pila con la instrucción glPushMatrix(); Aplicar la transformación nueva, definir los vértices de la figura(s) afectada(s), y posteriormente, si nos interesa seguir definiendo vértices que no deberían ser afectados por esta transformación, antes recuperar el estado anterior de la matriz desde la pila con glPopMatrix(); . Estas instrucciones que manipulan la pila de matrices son muy útiles, y aunque cuesta un poco entender como funcionan en un principio, son muy prácticas una vez que uno ha captado la idea.
estas primitivas y cual es su comportamiento. Hay algunos apuntes que hacer también al respecto pero eso lo reservaremos para otra ocasión, por ahora basta con saber que existen y que podemos hacer uso de ellas. Ahora veamos un ejemplo para estudiar de manera práctica las transformaciones lineales junto con algunas cosas nuevas.
Vamos al ejemplo!...
Demos un vistazo al Listado 1 , y veamos que podemos aprender de éste. Como podemos ver, hemos definido al principio un procedimiento que se encargará de dibujar el cubo que mostraremos en nuestra escena. Para esto lo que hicimos fue utilizar la primitiva GL_QUADS, la cual lo que hace es dibujar un cuadro con cada 4 vértices que nosotros definimos. Y como ven también, hemos definido un color diferente para cada uno de los 8 vértices que definen las aristas de nuestro cubo. Debido a que no hemos definido ningún modelado de despliegue para nuestra escena (todavía no llegamos a tanto), lo que se hace es tomar el default , y hacer un degradado entre los vértices de la figura, por eso es que vemos que las caras de esta se encuentran iluminadas por un degradado de colores bastante llamativo. Por ahora hemos definido la construcción de este cubo en un procedimiento separado, pero más adelante veremos como usar una herramienta bastante útil llamada las “listas de despliegue”, las cuales tienen una función semejante a lo que hacemos con este procedimiento. En los ejemplos anteriores habíamos usado a los formularios como lienzos, ¿recuerdan?...pero pudiera suceder que no nos interesara utilizar toda la superficie del formulario para desplegar nuestras escenas, sino solo una porción de éste, y el resto del espacio utilizarlo para colocar controles que manipulen la escena, ¿no?...Bueno, pues esta vez veremos como hacerlo. Para este ejemplo tomaremos como lienzo a un objeto de tipo Tpanel. Las primitivas geométricas Como ya no usaremos la versión de OpenGL.pas de Lischke, Hasta ahora en los ejemplos que habíamos visto solo habíamos ahora nos sumergiremos un poco más en las profundidades de usado líneas y puntos para crear nuestras figuras, pero en cómo inicializamos un contexto “a pie”, y entre las cosas que OpenGL existen muchísimas primitivas de figuras que ya debemos hacer de este modo es el formato de pixeles que iremos viendo a su tiempo. La figura 9 nos muestra algunas de 17
Transformaciones Lineales en OpenGL tusaremos en el control (en este caso el Panel). Para esto hemos el Panel, y dentro de este procedimiento, hemos definido las utilizado el procedimiento: procedure setupPixelFormat(DC:HDC) el cual nos servirá para este formato. Como ven hemos definido una constante pfd de tipo TPIXELFORMATDESCRIPTOR la cual contendrá toda la información acerca del formato que elijamos para nuestro control OpenGL, y esa es la que pasamos como parámetro a la función ChoosePixelFormat(); la cual recibe además el manejador del control donde desplegaremos la escena. Sobre los valores que componen el tipo de datos TPIXELFORMATDESCRIPTOR no hablaremos mucho por ahora, ya que a estas alturas hay cosas que todavía ni siquiera hemos mencionado, más adelante hablaremos de temas como los diferentes buffer’s, así como de las paletas de colores a utilizar. De igual manera que en los anteriores ejemplos, el contexto lo inicializamos cuando creamos la forma y lo liberamos al destruirla. Como pueden observar tenemos un procedimiento llamado dibuja(), el cual es el que se encarga de vaciar el frame-buffer en
transformaciones de rotación, traslación y escalamiento en función de propiedades de 3 componentes de tipo TtrackBar, las cuales se encargan de volver a dibujar la escena cada vez que sus posiciones cambian, ya que tenemos asociado este procedimiento al evento OnChange de estas componentes. En este ejemplo, hacemos rotaciones sobre el eje Y, traslaciones sobre el eje Z, y escalamientos sobre el eje X. Esto con el fin de poder apreciar como es que funcionan estas transformaciones. Y el orden en como aplicamos las transformaciones es: primero la traslación, luego la rotación y por último el escalamiento. El resto del programa no difiere demasiado de los que ya hemos visto anteriormente, así que no creo que requiera de mayores explicaciones. Además, los comentarios en el código explican cada línea a detalle. Como quiera aún tenemos mucho que aprender en el futuro. Que se diviertan con esto y hasta pronto.
Listado 1
unit Unit1; interface uses
Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, ExtCtrls, OpenGL, StdCtrls, ComCtrls; type
TForm1 = class(TForm) Panel1: TPanel; Timer1: TTimer; TrackBar1: TTrackBar; Label1: TLabel; TrackBar2: TTrackBar; Label2: TLabel; TrackBar3: TTrackBar; Label3: TLabel; procedure FormCreate(Sender: TObject); procedure FormDestroy(Sender: TObject); procedure Dibuja(Sender: TObject); private
{ Private declarations } public
{ Public declarations } end; var
Form1: TForm1; Angle: integer; implementation
{$R *.DFM}
18
Transformaciones Lineales en OpenGL procedure cubo; // Para dibujar el cubo de nuestra escena ... begin
glbegin(GL_QUADS); glcolor3f (10,10,10); glVertex3f (1.0, 1.0, 1.0); glcolor3f (-10,10,10); glVertex3f (-1.0, 1.0, 1.0); glcolor3f (-10,-10,10); glVertex3f (-1.0, -1.0, 1.0); glcolor3f (10,-10,10); glVertex3f (1.0, -1.0, 1.0); glcolor3f (10,10,-10); glVertex3f (1.0, 1.0, -1.0); glcolor3f (10,-10,-10); glVertex3f (1.0, -1.0, -1.0); glcolor3f (-10,-10,-10); glVertex3f (-1.0, -1.0, -1.0); glcolor3f (-10,10,-10); glVertex3f (-1.0, 1.0, -1.0); glcolor3f (-10,10,10); glVertex3f (-1.0, 1.0, 1.0); glcolor3f (-10,10,-10); glVertex3f (-1.0, 1.0, -1.0); glcolor3f (-10,-10,-10); glVertex3f (-1.0, -1.0, -1.0); glcolor3f (-10,-10,10); glVertex3f (-1.0, -1.0, 1.0); glcolor3f (10,10,10); glVertex3f (1.0, 1.0, 1.0); glcolor3f (10,-10,10); glVertex3f (1.0, -1.0, 1.0); glcolor3f (10,-10,-10); glVertex3f (1.0, -1.0, -1.0); glcolor3f (10,10,-10); glVertex3f (1.0, 1.0, -1.0); glcolor3f (-10,10,-10); glVertex3f (-1.0, 1.0, -1.0); glcolor3f (-10,10,10); glVertex3f (-1.0, 1.0, 1.0); glcolor3f (10,10,10); glVertex3f (1.0, 1.0, 1.0); glcolor3f (10,10,-10); glVertex3f (1.0, 1.0, -1.0); glcolor3f (-10,-10,-10); glVertex3f (-1.0, -1.0, -1.0); glcolor3f (10,-10,-10); glVertex3f (1.0, -1.0, -1.0); glcolor3f (10,-10,10); glVertex3f (1.0, -1.0, 1.0); glcolor3f (-10,-10,10); glVertex3f (-1.0, -1.0, 1.0); glEnd; end; 19
Transformaciones Lineales en OpenGL procedure setupPixelFormat(DC:HDC); //Para definir el formato de pixeles a usar... const
pfd:TPIXELFORMATDESCRIPTOR = ( nSize:sizeof (TPIXELFORMATDESCRIPTOR); // tamaño nVersion:1; // versión dwFlags:PFD_SUPPORT_OPENGL or PFD_DRAW_TO_WINDOW or PFD_DOUBLEBUFFER; // usamos doble-buffer iPixelType:PFD_TYPE_RGBA; // Tipo de color cColorBits:16; // paleta a usar... cRedBits:0; cRedShift:0; // bits de color cGreenBits:0; cGreenShift:0; cBlueBits:0; cBlueShift:0; cAlphaBits:0; cAlphaShift:0; // no usamos buffer alfa... cAccumBits: 0; cAccumRedBits: 0; // ni tampoco cAccumGreenBits: 0; // valores de acumulación cAccumBlueBits: 0; cAccumAlphaBits: 0; cDepthBits:16; // buffer de profundidad cStencilBits:0; // no usamos Stencil Buffer =:-( cAuxBuffers:0; // ni buffers auxiliares iLayerType:PFD_MAIN_PLANE; bReserved: 0; dwLayerMask: 0; dwVisibleMask: 0; dwDamageMask: 0; ); var pixelFormat:integer; begin
pixelFormat := ChoosePixelFormat(DC, @pfd); if (pixelFormat = 0) then begin MessageBox(WindowFromDC(DC), 'Fallo en la elección del formato' , 'Error' , MB_ICONERROR or MB_OK); exit; end; if (SetPixelFormat(DC, pixelFormat, @pfd) <> TRUE) then begin MessageBox(WindowFromDC(DC), 'Fallo en la asignación del formato' , 'Error' , MB_ICONERROR or MB_OK); exit; end; end; procedure TForm1.FormCreate(Sender: TObject); var DC:HDC;
RC:HGLRC; begin
DC:=GetDC(Panel1.Handle); SetupPixelFormat(DC); RC:=wglCreateContext(DC); wglMakeCurrent(DC, RC);
//Esta vez nos conectamos //con el manejador del Panel ...
glViewport(0, 0, Form1.Panel1.Width, Form1.Panel1.Height); glMatrixMode(GL_PROJECTION); // Activamos la matriz de proyección y glLoadIdentity; // cargamos la matriz identidad gluPerspective(35,Form1.Panel1.Width / Form1.Panel1.Height,1,100); //Definimos la perspectiva end;
20
Transformaciones Lineales en OpenGL procedure TForm1.FormDestroy(Sender: TObject); var DC:HDC;
RC:HGLRC; begin
DC := wglGetCurrentDC; //Cuando destruyamos la forma RC := wglGetCurrentContext; //debemos liberar el contexto del Panel wglMakeCurrent(0, 0); if (RC<>0) then wglDeleteContext(RC); if (DC<>0) then ReleaseDC(Panel1.Handle, DC); end; procedure TForm1.Dibuja(Sender: TObject); begin
glClearColor(0,0,0.3,1); // el color del fondo glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); // Borramos la pizarra... glMatrixMode(GL_MODELVIEW); // activamos la matriz de transformaciones y glLoadIdentity; // Cargamos la matriz identidad... gluLookAt(0,0,6,0,0,-10,0,1,0); // definimos un punto de observación... glTranslatef (0,0,Trackbar2.Position); // Trasladamos la figura respecto al eje Z... glRotatef (TrackBar1.Position,0,1,0); // Rotamos sobre el eje Y.... glRotatef (30,1,0,0); // Aplicamos otra pequeña rotación para obtener perspectiva... glScalef (TrackBar3.Position / 20,1,1); //Escalamos respecto al eje X... glEnable(GL_DEPTH_TEST); // Habilitamos la prueba de profundidad.... Cubo; //Dibujamos el cubo... SwapBuffers(wglGetCurrentDC); //Vaciamos el frame-buffer en el panel... Timer1.Enabled := False; end; end
21
Interacción de gráficos con dispositivos
tridimensionales sin demasiado esfuerzo, por ahora nos limitaremos a usar los predefinidos de OpenGL.
Veamos el ejemplo, ¿cómo respondemos a los eventos?
Cómo podemos obtener programas gráficos Bien, en el ejemplo del número anterior veíamos como interactivos de manera simple usando podíamos crear un contexto de OpenGL sobre un componente componentes creados en tiempo de Tpanel, ¿recuerdan?, pero bueno, en realidad podemos crear ejecución este tipo de contextos en cualquier componente que esté Para esta ocasión hemos preparado un pequeño articulo sobre cómo podemos crear programas que resulten interactivos para el usuario, es decir, hacer a este participar en la ejecución, y no limitarlo solo a observar los resultados de todos los cálculos matemáticos internos que deben realizarse para presentar gráficos en tres dimensiones. ¿Familiar, no?... Este es el concepto que se utiliza frecuentemente en los juegos de video para computadora... Son muy comunes hoy en día y algunos de ellos son verdaderamente sorprendentes por la calidad de imágenes que muestran y lo interesantes que suelen ser. Pues bien, ahora empezaremos con un paso elemental, que es el como interactuar con los eventos causados por el usuario de nuestra aplicación, esta vez veremos como responder a los eventos del ratón y el teclado.
¿Cómo hacemos cuerpos complejos en OpenGL? Bien, OpenGL provee además de las primitivas básicas que ya hemos visto hasta ahora, algunos cuerpos complejos que suelen ser de utilidad en algunas ocasiones. La ventaja de estos cuerpos es que la manera en como son construidos y mostrados al usuario está muy optimizada, para hacer las aplicaciones bastante rápidas. Además de que nos evitan estar ideando la manera de cómo crear procedimientos para construir estos objetos que también suelen ser de uso bastante común. Los que en esta ocasión estudiaremos se encuentran en la librería GLU32.DLL. ¿Recuerdan cuando en algún articulo pasado mencionábamos que en esta librería se encontraban algunas figuras ya predefinidas?. Pues bien, así es, aquí podemos encontrar procedimientos para construir: cilindros, conos (que en realidad vienen a ser una especialización de un cilindro), discos y esferas. Los nombres de los procedimientos que crean estos cuerpos comienzan con las siglas glu, y reciben diferentes parámetros cada uno, dependiendo del tipo de cuerpo que deseamos construir. Por ejemplo, para construir un cilindro lo que indicamos como parámetros, son: la altura que deberá tener este cilindro, así como la longitud de los 2 radios que lo componen. Y para el caso de las esferas, debemos indicar el radio, y el número de paralelos y meridianos que la compondrán (dependiendo de el número de paralelos y meridianos que definamos será la calidad en la definición de nuestra esfera). Para cada uno de los objetos que creemos con las funciones de glu, debemos asignar un identificador de tipo gluQuadricObj, el cual es en realidad un apuntador a una zona de memoria donde se construirá el objeto en cuestión. No es tan complicado, ya lo veremos mas claro en el ejemplo. En otra ocasión veremos como crear nuestros propios cuerpos
derivado de la clase TCustomControl. De todos es sabido que Delphi es un poderoso lenguaje orientado a objetos, y pues estaría mal que nosotros no utilizáramos esta gran ventaja a la hora de programar gráficos, ¿no?. Supongamos que lo que ahora nos interesa es poder desplegar nuestra escena 3D sobre una porción del formulario, y responder a los eventos del ratón solo en esa determinada región. Una solución sería usar un componente Tpanel como en el ejemplo anterior, pero bueno, vamos a hacer un componente especial para lo que ahora nos interesa específicamente. Como pueden ver en el “Listado 1”, hemos definido una clase llamada GLControl derivada de TCustomControl, la cual nos servirá precisamente como nuestro lienzo y controlador de eventos. Como pueden observar, en el evento OnCreate del formulario asignamos las coordenadas que tendrá nuestro componente, inicializamos el contexto OpenGL, y por último asociamos nuestros procedimientos para responder a los eventos del ratón. Como pueden ver volvemos a hacer uso de la función SetupPixelFormat(), la cual usaremos siempre que creemos un contexto “a medida”. También usamos dos procedimientos extras: Draw(), el cual se encarga de dibujar y mostrar la escena, y GLInit() que se encarga de configurar la perspectiva y el ambiente de la escena. Cabe señalar aquí, que en este ejemplo tuvimos que definir algunas luces a fin de que se pudieran distinguir con claridad los cuerpos que habíamos creado, pero ya tocaremos el tema de la iluminación más a fondo en otra ocasión.
Bueno, pero ¿cómo hago que un cuerpo se mueva tridimensionalmente de acuerdo al movimiento del ratón? Bien, para eso debemos utilizar algunas variables auxiliares para lograr el efecto. Primeramente aclaremos que lo que haremos aquí será solo simular la rotación de un cuerpo respecto a dos ejes dimensionales, es decir solamente rotaciones en los ejes X e Y ; sin embargo puede quedárseles de tarea como podríamos además trasladar el cuerpo respecto al eje Z (para obtener efectos de zoom) arrastrando por ejemplo el ratón con el botón derecho presionado. De cualquier modo aquí simulamos ese efecto con un TTrackBar como en el ejemplo del número pasado. Usaremos dos variables para controlar los ángulos que se verán afectados para cada uno de los ejes, otras dos para controlar el desplazamiento del movimiento con respecto a estos ángulos, y por último otras dos para determinar el punto de inicio del movimiento. ¿Sencillo, no?. Pensemos en que estaremos desplazando el ratón sobre una superficie bidimensional, al cual le daremos un comportamiento tridimensional, algo que en teoría no es tan simple. 22
Interacción de gráficos con dispositivos Ahora veamos lo que debemos de programar para ir modificando estas variables: Primero veamos que en el evento OnMouseDown() lo único que debemos hacer es almacenar las coordenadas donde el usuario ha pulsado el botón del ratón (ahora no estamos haciendo distinción de que botón ha sido presionado). En el evento OnMouseMove() lo que hacemos es verificar si está presionado el botón izquierdo del ratón, en cuyo caso debemos modificar el desplazamiento sobre los ángulos con respecto a las coordenadas de inicio del movimiento, y las coordenadas sobre las que estamos desplazándonos. En este caso podemos aplicar un factor de suavizado, el cual es un número que nos servirá para hacer menos bruscos los movimientos en sistemas más rápidos. Para aplicar este factor solo debemos dividir las diferencias de las coordenadas entre este factor, en nuestro caso usamos un factor de dos unidades. Por último, en el evento OnMouseUp(), solo nos resta sumar a los ángulos de referencia los desplazamientos obtenidos en OnMouseMove() e inicializar dichos desplazamientos nuevamente a cero. Ahora veamos como dibujamos la escena respecto a estas variables con instrucciones de rotación de OpenGL: La instrucción glRotatef(alpha+dx,0.0,1.0,0.0); nos permite rotar el cuerpo respecto al eje Y , usando como referencia las variables de inclinación y desplazamiento del eje X . Y por el otro lado, la instrucción glRotatef(betha+dy,1.0,0.0,0.0); hace lo propio con el otro eje. Y esto produce a final de cuentas el efecto de que los cuerpos definidos parecen “seguir ” el movimiento del ratón sobre nuestro control. Debemos tener en cuenta que todo esto lo hemos hecho para poder tener una referencia en dos ejes para un solo cuerpo, pero con un poco más de ciencia podríamos generalizar el método para aplicarlo a todos los objetos de una escena, o solamente a unos cuantos de ellos. Del mismo modo podríamos programar procedimientos que respondieran a eventos generados por el teclado asignándolos a los eventos OnKeyDown(), OnKeyUp() y OnKeyPress() de nuestro control. Cabe señalar que en nuestro ejemplo también podemos obtener respuesta a las teclas de cursor de nuestro teclado, siempre y cuando el TrackBar tenga el foco en nuestra aplicación. Una vez habiendo realizado todo esto tenemos nuestra aplicación ya terminada (Ver figura 1). Esto es solo un comienzo, pero es un muy buen comienzo.
Listado
Figura 1.- Nuestra aplicación en ejecución
Consideraciones adicionales con otros dispositivos Hasta aquí ya hemos visto como podemos interactuar de una manera muy simple con el ratón y el teclado, sin embargo existen en la red diversos componentes que permiten también recibir eventos desde un Joystick por ejemplo, en cuyo caso, no existe mucha diferencia con lo visto hasta ahora. Y en caso de que nos interesara guardar una escena como un archivo de imagen, ó bien imprimirla tampoco hay mayor problema, ya que basta con usar la famosa función CopyRect() del objeto Canvas asociado con el control sobre el cual desplegamos nuestra escena y con ese rectángulo podemos hacer lo que se nos pegue en gana. Bueno, hasta aquí llegamos por esta vez, que tengan suerte, y que aprendan mucho de esto Hasta Pronto.
1
unit Unit1; interface uses OpenGL, Windows, Messages, SysUtils, Classes, Graphics, Controls, Forms, Dialogs, StdCtrls, ExtCtrls, ComCtrls;
23
Interacción de gráficos con dispositivos type {Nuestra nueva clase para controlar el movimiento del ratón sobre una región del formulario} TGLControl=class(TCustomControl) public property OnMouseDown; property OnMouseUp; property OnMouseMove; property OnKeyDown; end; {Un tipo enumerado para los cuerpos que podemos dibujar} TCuerpo =(cono,cilindro,esfera); {La definición de nuestro formulario} TForm1 = class(TForm) TrackBar1: TTrackBar; Label1: TLabel; ComboBox1: TComboBox; procedure FormCreate(Sender: TObject); procedure TrackBar1Change(Sender: TObject); procedure FormPaint(Sender: TObject); procedure ComboBox1Change(Sender: TObject); private //Para el movimiento del Ratón usamos estas variables... alpha, betha:GLfloat; //angulo para los eventos del Ratón dx,dy:GLFloat; //Actual desplazamiento de los angulos mStartX,mStartY:integer; //Punto de inicio del movimiento del ratón cuerpo:TCuerpo; GLC:TGLControl; //Control para controlar la salida OpenGL procedure Draw; //Dibuja la escena... //Nuestro evento de OnMouseDown para el nuevo control... procedure GLMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); //Nuestro evento de OnMouseUp para el nuevo control... procedure GLMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); //Nuestro evento de OnMouseMove para el nuevo control... procedure GLMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); public { Declaraciones públicas} end;
var Form1: TForm1; implementation {$R *.DFM}
procedure setupPixelFormat(DC:HDC); const pfd:TPIXELFORMATDESCRIPTOR = ( nSize:sizeof(TPIXELFORMATDESCRIPTOR); // Tamaño nVersion:1; // versión
24
Interacción de gráficos con dispositivos dwFlags:PFD_SUPPORT_OPENGL or PFD_DRAW_TO_WINDOW or PFD_DOUBLEBUFFER; // Usamos un soporte para el double-buffering iPixelType:PFD_TYPE_RGBA; // tipo de colores cColorBits:16; cRedBits:0; cRedShift:0; // ignoramos los colores cGreenBits:0; cGreenShift:0; cBlueBits:0; cBlueShift:0; cAlphaBits:0; cAlphaShift:0; // sin buffer de transparencias cAccumBits: 0; cAccumRedBits: 0; cAccumGreenBits: 0; // Ignoramos la acumulación cAccumBlueBits: 0; cAccumAlphaBits: 0; cDepthBits:16; // usamos un buffer de profundidad de 16 bits cStencilBits:0; // ni buffer de Stencil cAuxBuffers:0; // sin buffers auxiliares iLayerType:PFD_MAIN_PLANE; // Solo usamos un plano principal bReserved: 0; dwLayerMask: 0; dwVisibleMask: 0; dwDamageMask: 0; ); var pixelFormat:integer; begin pixelFormat := ChoosePixelFormat(DC, @pfd); if (pixelFormat = 0) then begin MessageBox(WindowFromDC(DC), 'Fallo el la elección del formato.', 'Error', MB_ICONERROR or MB_OK); exit; end; if (SetPixelFormat(DC, pixelFormat, @pfd) <> TRUE) then begin MessageBox(WindowFromDC(DC), 'Fallo en la elección del formato.', 'Error', MB_ICONERROR or MB_OK); exit; end; end;
procedure GLInit; const light0_position:array [0..3] of GLfloat=( 4.0, 4.0, 4.0, 0.0); specular: array [0..3] of GLfloat=( 1.0, 1.0, 0.0, 1.0); diffuse: array [0..3] of GLfloat=( 1.0, 1.0, 1.0, 0.7); begin // Asignamos una posición de observación para la escena glMatrixMode(GL_PROJECTION); glFrustum(-0.1, 0.1, -0.1, 0.1, 0.3, 25.0); //Cargamos la matriz de modelado... glMatrixMode(GL_MODELVIEW); //Definimos un nuevo modelo de despliegue... glShadeModel(GL_FLAT); //Habilitamos la prueba de profundidad... glEnable(GL_DEPTH_TEST); //Habilitamos una luz... glEnable(GL_LIGHTING); glLightfv(GL_LIGHT0, GL_POSITION, @light0_position); glLightfv(GL_LIGHT0, GL_DIFFUSE, @diffuse);
25
Interacción de gráficos con dispositivos glLightfv(GL_LIGHT0, GL_SPECULAR, @specular); glEnable(GL_LIGHT0); glEnable(GL_COLOR_MATERIAL); end;
procedure TForm1.FormCreate(Sender: TObject); var DC:HDC; RC:HGLRC; begin //Creamos un comtrol para correr OpenGL sobre él... GLC:=TGLControl.Create(self); GLC.Parent:=self; GLC.Left:=10; GLC.Top:=10; GLC.Width:=300; GLC.Height:=300; //Obtenemos el manejador del control para crear un contexto OpenGL en él... DC:=GetDC(GLC.Handle); //Asignamos un formato de pixelado al contexto... SetupPixelFormat(DC); RC:=wglCreateContext(DC); //creamos propiamente el Contexto... wglMakeCurrent(DC, RC); //y lo activamos GLInit; //Inicializamos las variables OpenGL //Conectamos los eventos de nuestro control con los procedimientos que definimos... GLC.OnMouseDown:=GLMouseDown; GLC.OnMouseMove:=GLMouseMove; GLC.OnMouseUp:=GLMouseUp; //Empezamos dibujando un Cono... ComboBox1.ItemIndex:=0; end; procedure TForm1.Draw; var quad:GLUquadricObj; //Usamos una variable de este tipo para dibujar figuras complejas... begin // Borramos los buffers... glClear(GL_COLOR_BUFFER_BIT or GL_DEPTH_BUFFER_BIT); glLoadIdentity; //Trasladamos la escena respecto al TrackBar... glTranslatef(0.0, 0.0, -TrackBar1.Position/10); //Rotamos la escena respecto a nuestras variables de control... glRotatef(alpha+dx,0.0,1.0,0.0); glRotatef(betha+dy,1.0,0.0,0.0); // Ahora dibujamos el cuerpo ... quad:=gluNewQuadric; case cuerpo of cono: gluCylinder(quad,0.5,0.0,1,48,1); cilindro:gluCylinder(quad,0.5,0.5,1,48,1); esfera: gluSphere(quad,0.5,32,32); end; glTranslatef(-2,0,0); gluDeleteQuadric(quad); //Mostramos la escena construida... SwapBuffers(wglGetCurrentDC); end; procedure TForm1.TrackBar1Change(Sender: TObject); begin Draw; end;
26
Interacción de gráficos con dispositivos procedure TForm1.FormPaint(Sender: TObject); begin Draw; end; procedure TForm1.GLMouseDown(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Label1.Caption:=Format('abajo: %d, %d',[X,Y]); mStartX:=X; mStartY:=Y; end; procedure TForm1.GLMouseUp(Sender: TObject; Button: TMouseButton; Shift: TShiftState; X, Y: Integer); begin Label1.Caption:=Format('arriba: %d, %d',[X,Y]); //Ajustamos los nuevos ángulos de visualización... alpha:=alpha+dx; dx:=0.0; betha:=betha+dy; dy:=0.0; end; procedure TForm1.GLMouseMove(Sender: TObject; Shift: TShiftState; X, Y: Integer); begin if (ssLeft in Shift) then begin Label1.Caption:=Format('moviendo: %d, %d',[X,Y]); dx:=(x-mStartX)/2; dy:=(y-mStartY)/2; Draw; end; end; procedure TForm1.ComboBox1Change(Sender: TObject); begin // Con esto seleccionamos el tipo de cuerpo que deseamos dibujar... cuerpo :=TCuerpo(ComboBox1.ItemIndex); Draw; end; end.
27
Tipos de proyecciones y manejo de la cámara en OpenGL Como pasar de coordenadas 3D a coordenadas de dos dimensiones, y como interactuar con la cámara. Bien, en esta ocasión vamos a tratar de dar continuidad al artículo del mes pasado hablando de cómo podemos interactuar en la escena que mostramos a traves de los dispositivos de entrada como el teclado y el ratón, y esta vez daremos un ejemplo un poco más completo al respecto. También hablaremos más específicamente sobre las técnicas de proyección que nos brinda OpenGL, y como es que trabajan en teoría cada una de ellas. Este es un concepto que de algún modo resulta interesante conocer, ya que puede llegar a ser sumamente útil a la hora de crear nuestras propias aplicaciones gráficas, pues de esto puede depender la calidad de nuestra presentación.
¿Cómo pasar de coordenadas 3D a coordenadas 2D en nuestra ventana? Esta es una muy buena pregunta, ¿Cómo hacer que aparezcan en nuestra ventana, que es 2D, puntos que en realidad deberán tener una relación de profundidad entre sí?... Bien, pues la respuesta no es tan compleja si la pensamos un poquito, lo que hay que hacer es proyectar toda nuestra geometría en un plano, al que llamaremos Plano de Proyección. Como todos los planos, este representa una región 2D, y por convención suele situarse en Z = 0, es decir en el plano XY . Y primero debemos hacer la proyección para después hacer las conversiones de tipos de coordenadas. Entendamos esto de las conversiones de tipos: Cuando trabajamos con coordenadas 3D, es común que las definamos como números de punto flotante, y es perfectamente válido hacer esto, si no ¡imagínense como funcionarían programas de diseño como por ejemplo Autocad usando solo aritmética entera!...Sin embargo, nuestro monitor está mapeado en pixeles que tienen cada uno dos coordenadas enteras, por esta razón es que debemos hacer una conversión que elimine los decimales sin que estos dejen de ser significativos en la proyección. Por eso es que hay que convertir forzosamente al final a enteros. Existen muchos tipos de proyecciones y podríamos escribir libros completos al respecto, pero aquí nos limitaremos a ver solo dos que resultan algo significativas para nuestros propósitos, la proyección Ortográfica, y la proyección en Perspectiva . Ambas están clasificadas dentro de las proyecciones planares. Y básicamente ambas consisten en definir una línea de visión que va desde el observador hasta el objeto observado, y trazar una serie de líneas que cortarán el plano de proyección que hayamos definido generando así la figura 2D
que finalmente aparecerá en nuestra pantalla.
La proyección Ortográfica Este tipo de proyección está clasificada como un tipo de proyección paralela, y esto es porque consiste en trazar líneas perpendiculares al plano de proyección que resultan ser paralelas entre sí. Este es una tipo de proyección relativamente sencilla, que suele ser bastante útil en ciertos casos. La figura 1 muestra gráficamente como se construyen las líneas paralelas en esta proyección, podemos ver como se
Figura 1. Proyección Ortográfica obtiene un dibujo de una de las caras de nuestro cubo en nuestro plano de proyección y así obtenemos lo que veremos en pantalla. Este tipo de proyección no preserva las dimensiones reales de los objetos según la distancia hasta ellos. Con eso queremos decir que aún acercándose ó alejándose de ellos no se producen cambios de tamaño con lo cual el realismo no es total. Se utiliza tradicionalmente en proyectos de ingeniería del tipo de programas CAD/CAM. Quién no ha visto una herramienta de modelación 3D (AutoCAD, 3DSMax, etc...) sin las 3 correspondientes vistas ortográficas desde ambos laterales y desde arriba. La cuarta vista suele ser una perspectiva que comentaremos a continuación. Los parámetros a especificar en este caso son las dimensiones de una caja (Xmin, Xmax, Ymin, Ymax, Zmin, Zmax). A los valores MAX y MIN también se les denomina FAR o BACK y NEAR o FRONT. ¿Qué por qué una caja?... pues porque también hay que definir nuestro campo visual, donde campo visual es la "cantidad" de mundo que la cámara alcanza a ver. Porque imagínense que ustedes tienen “Ojo de águila” y alcanzan a ver mucho más de lo que un topo medio ciego que apenas distingue su propia nariz, ¡Ah verdad!... pues esta caja determina qué tan buena vista tendremos en nuestra aplicación. En OpenGL la podemos definir de la siguiente forma: Cargamos la matriz de proyección, la inicializamos y usamos glOrtho(x_min, x_max, y_min, y_max, z_min, z_max); ó bien: gluOrtho2D(x_min, x_max, y_min, y_max); si se aceptan los valores por defecto de Zmin = -1.0 y Zmax = 1.0. Ya habíamos hecho alguna vez en artículos anteriores una proyección Ortogonal, cuando hablábamos de cómo hacer gráficas en 2D y en esa ocasión usamos gluOrtho2D()... ¡¡revisen sus apuntes!!
28
Tipos de proyecciones y manejo de la cámara en OpenGL La proyección en Perspectiva Esta es la que definitivamente utilizaremos para dotar del mayor realismo a nuestras aplicaciones. Las proyecciones perspectiva preservan las dimensiones reales de los objetos si nos acercamos ó alejamos de ellos. Por tanto el efecto visual es justo el que necesitamos en casos de apariencia real. Veamos la figura 2 para tener una mejor idea de cómo funciona.
su posición y orientación. Tenemos que acotar en este sentido y es por eso que además de definir un plano de proyección y una forma de proyectar, creamos un volumen de visualización finito con unas fronteras bien marcadas. Todo aquello que no se encuentre dentro del volumen será rechazado y no proyectado dado que no debe verse. Para tenerlo más claro pensemos en nuestros propios ojos. ¿Acaso vemos todo a nuestro alrededor?...no...tenemos una cierta apertura visual, de unos 60º a 80º y más allá de eso nada de nada, solo conjeturas. No somos como las palomas con los ojos en los laterales de la cabeza o como una gran lente angular de una cámara. De hecho tan sólo variando la apertura visual (FOV) observaremos como es más o menos la cantidad de escena que entra en pantalla.
Ahora vamos con la camara... La cámara son nuestros ojos virtuales. Todo lo que ella vea será proyectado, discretizado y finalmente mostrado en la ventana de nuestra aplicación. Podemos imaginar que de la cámara emana el volumen de visualización de forma que se traslada con ella. Los parámetros a definir en cuanto a la cámara son: Posición XYZ en el mundo 3D. Al igual que un objeto cualquiera, la cámara debe posicionarse. En un juego arcade Figura 2. Proyección en Perspectiva 3D típico la cámara nos da la visión frontal del mundo y se En la figura tenemos una proyección perspectiva con un sólo va moviendo a nuestro antojo con las teclas o el ratón. Cada COP o punto de fuga . Todas las líneas ó proyectores vez que modificamos la posición varían las coordenadas XYZ emanan de él y se dirigen hasta el objeto intersectando el de cámara. Orientación. Una vez situada debe orientarse. plano de proyección. Como podemos observar en este caso Osea, yo puedo estar quieto pero girar la cabeza y mirar hacía donde me venga en gana. Dirección de "AT". Define los proyectores no son paralelos entre ellos. En OpenGL definimos esta proyección cargando la matriz de hacia dónde estoy mirando, a qué punto concretamente. OpenGL definimos la c ámara con: proyección, inicializandola, y usando gluPerspective( FOV en grados, En glulookAt(eyeX,eyeY,eyeZ,atX,atY,atZ,upX,upY,upZ); Relación de Aspecto, z_near, z_far); donde los parámetros que hay Esta es la función que determina dónde y cómo está que pasarle a este método son los siguientes: El FOV se refiere al ángulo de abertura inicial, que dispuesta la cámara. Cuidado que la posición de la cámara no determinará nuestro campo de visión. La relación de aspecto tiene nada que ver con el tipo de proyección que hayamos es el cociente entre la anchura y la altura del plano de definido. La proyección se define sólo una vez, típicamente proyección deseado, es decir de nuestra ventana, ó el control al principio del programa en una función inicializadora, que usaremos para desplegar nuestra escena. Y los valores mientras que la cámara se mueve continuamente según nos Near y Far son los mismos que en la proyección ortográfica, interese y más en un juego 3D !!!. Añadir a esto que la matriz es decir que determinan qué tan lejos y tan cerca seremos que se modifica al llamar a esta función no tiene que ser GL_PROJECTION sino GL_MODELVIEW. OpenGL calculará todas las capaces de ver. Podemos definir también una proyección perspectiva usando transformaciones que aplicará al mundo 3D para que la función: glFrustrum(x_min, x_max, y_min, y_max, z_min, z_max);. En este manteniendo la cámara en el origen de coordenadas y caso OpenGL calculará el "frustrum piramidal", es decir, el enfocada en la dirección negativa de las Z's, nos dé la volumen de visualización perspectiva más idóneo. Son sensación de que lo estamos viendo todo desde un cierto simplemente dos maneras distintas de acabar creando lo lugar. Para ello debemos recordar siempre activar esta matriz antes de llamar a gluLookAt(). mismo. A cada uno con su elección...¿no creen?... Las distancias NEAR y FAR son siempre positivas y En cuanto a los parámetros que demanda la función son los medidas desde el COP hasta esos planos, que serán siguientes: obviamente paralelos al plano Z = 0. Dado que la cámara Coordenadas del "eye". Es literalmente la posición XYZ apunta por defecto en la dirección negativa de Z, el plano de dónde colocar la cámara dentro del mundo. Coordenadas front (near) estará realmente situado en z = -zmin mientras del "at". Es el valor XYZ del punto al que queremos que mire la cámara. Un punto del mundo obviamente. que el de back (far) estará en z = -zmax . Lo hemos dado más o menos por asumido pero vamos a Coordenadas del vector "up". Si, es un vector y no un recordar un poco. Pensemos que no hay que proyectar toda la punto. Con él regularemos la orientación de la cámara. Este geometría existente sino tan sólo la que ve la cámara desde ha de ser el vector que "mira hacia arriba" si entendemos que el vector que mira hacia adelante es el que va del "eye" hasta 29
