Departamento de Tecnologías de la Información Tema 2 Dibujando Ciencias de la Computación e Inteligencia Artificial
Índice 2.1 Primitivas geométricas 2.2 Transformaciones geométricas 2.3 Proyecciones 2
Índice 2.1 Primitivas geométricas 2.2 Transformaciones geométricas 2.3 Proyecciones 3
2.1 Primitivas geométricas La base de cualquier dibujo geométrico en 3D es el vértice (vertex), que representa un punto tridimensional. OpenGL admite diferentes tipos de datos para describir los vértices. Las funciones utilizadas para crear un vértice se llaman glvertex..(), con el sufijo representando el tipo de dato utilizado. 4
2.1 Primitivas geométricas Por ejemplo, GLfloat v[3] = { 1.f, 2.f, -5.f }; glvertex3f(1.f, 2.f, -5.f); glvertex3d(1., 2., -5.); glvertex3fv(v); glvertex2f(1.f, 2.f); // asume z= 5
2.1 Primitivas geométricas Para representar una figura geométrica básica (una primitiva) se utilizan las funciones glbegin() y glend(), definiendo entre estas dos funciones el conjunto de vértices que forman la primitiva. OpenGL admite las siguientes primitivas, que se introducen como parámetro de la función glbegin(): GL_POINTS GL_LINES GL_TRIANGLES GL_POLYGON GL_QUADS GL_LINE_STRIP GL_LINE_LOOP GL_TRIANGLE_STRIP GL_TRIANGLE_FAN GL_QUAD_STRIP 6
2.1 Primitivas geométricas La primitiva GL_POINTS permite dibujar un conjunto de puntos. El siguiente ejemplo pinta un conjunto de puntos formando una circunferencia. glbegin(gl_points); for(int i=; i<2; i++) { GLfloat x = sin(3.1416*i/1)*5.f; GLfloat y = cos(3.1416*i/1)*5.f; Glfloat z = -2.f; } glvertex3f(x, y, z); glend(); 7
2.1 Primitivas geométricas Por defecto, el tamaño del punto es de un pixel. El tamaño del punto se puede modificar con la función void glpointsize(glfloat size); No todos los tamaños son válidos. Para obtener el rango de tamaños válidos se usa: GLfloat sizes[2]; glgetfloatv(gl_point_size_range, sizes); Para obtener la granularidad (diferencia entre dos tamaños) se usa: GLfloat step; glgetfloatv(gl_point_size_granularity, &step); 8
2.1 Primitivas geométricas Para dibujar líneas se utilizan las primitivas GL_LINES, GL_LINE_STRIP y GL_LINE_LOOP. La primitiva GL_LINES dibuja un conjunto de líneas rectas independientes. Cada pareja de vértices determina el comienzo y el fin de una línea (por ejemplo, para definir 4 líneas es necesario introducir 8 vértices entre los comandos glbegin() y glend() ). Si el número de vértices es impar, el último vértice se ignora. La primitiva GL_LINE_STRIP dibuja un conjunto de lineas rectas encadenadas, de manera que el vértice final de una línea es el vértice inicial de la siguiente. La primitiva GL_LINE_LOOP dibuja un conjunto de líneas rectas encadenadas donde el último vértice se une con el primero. 9
2.1 Primitivas geométricas El siguiente ejemplo pinta un conjunto de líneas formando una circunferencia. glbegin(gl_line_loop); for(int i=; i<2; i++) { GLfloat x = sin(3.1416*i/1)*5.f; GLfloat y = cos(3.1416*i/1)*5.f; Glfloat z = -2.f; } glvertex3f(x, y, z); glend(); 1
2.1 Primitivas geométricas Al igual que con los puntos, por defecto el grosor de las líneas es de un pixel. El grosor de las líneas se puede modificar con la función void gllinewidth(glfloat width); No todos los tamaños son válidos. Para obtener el rango de tamaños válidos se usa: GLfloat sizes[2]; glgetfloatv(gl_line_width_range, sizes); Para obtener la granularidad (diferencia entre dos tamaños) se usa: GLfloat step; glgetfloatv(gl_line_width_granularity, &step); 11
2.1 Primitivas geométricas Se puede modificar el estilo de línea para generar patrones intermitentes (líneas de puntos o de guiones). Para ello es necesario activar la opción: glenable(gl_line_stipple); Para establecer el patrón de intermitencia se usa la función gllinestipple(glint factor, GLushort pattern); El patron contiene un valor de 16 bits que indica la intermitencia (el bit 1 indica que se dibuja el pixel y el que no se dibuje). Por ejemplo, x5555 representa el código 11111111, es decir, se pintaría un bit si y otro no. El factor determina el numero de píxeles que afecta cada bit. Por ejemplo, un factor 2 con el patrón anterior indica que se dibujan dos píxeles si y dos no. 12
2.1 Primitivas geométricas Las primitivas GL_TRIANGLES, GL_TRIANGLE_STRIP y GL_TRIANGLE_FAN dibujan un conjunto de triángulos. La primitiva GL_TRIANGLES dibuja triángulos independientes. Cada tres vértices determinan un triángulo. Si el número de vértices no es divisible entre tres los vértices sobrantes se ignoran. V V 1 V 3 V 4 V 5 V 2 13
2.1 Primitivas geométricas La primitiva GL_TRIANGLE_STRIP dibuja un conjunto de triángulos en los que los dos últimos vértices son los dos primeros vertices del triángulo siguiente. Es decir, con N vértices se dibujan N-2 triángulos. V V 1 V 3 V 2 V 5 V 4 14
2.1 Primitivas geométricas La primitiva GL_TRIANGLE_FAN dibuja un conjunto de triángulos formados alrededor del primer vértice. Esto permite, por ejemplo, dibujar fácilmente una aproximación a un círculo por medio de triángulos. V 1 V V 2 V 5 V 3 V 4 15
2.1 Primitivas geométricas Las primitivas GL_QUADS y GL_QUAD_STRIP dibujan un conjunto de cuadriláteros. La primitiva GL_QUADS dibuja cuadriláteros independientes. Cada cuatro vértices determinan un cuadrilátero. Si el número de vértices no es divisible entre cuatro los vértices sobrantes se ignoran. V V 1 V 3 V 2 16
2.1 Primitivas geométricas La primitiva GL_QUAD_STRIP dibuja un conjunto de cuadriláteros en los que los dos últimos vértices son los dos primeros vertices del cuadrilátero siguiente. V 1 V 3 V 5 V V 2 V 4 17
2.1 Primitivas geométricas La primitiva GL_POLYGON dibuja un polígono formado por un número indefinido de vértices. Los polígonos deben cumplir ciertas restricciones: deben ser planos, convexos y sus lados no pueden intersectar. V 1 V 2 V 3 V V 4 V 5 18
2.1 Primitivas geométricas Los polígonos definen una superficie con dos caras. OpenGL permite distinguir las dos caras (front y back) estudiando el sentido de giro de las líneas que han construido el polígono. Por defecto, la cara frontal es la que se forma con líneas en sentido contrario a las agujas del reloj. Para seleccionar cual es la cara frontal se utiliza la función glfrontface(gl_cw); // clockwise glfrontface(gl_ccw); // cuonterclockwise 19
2.1 Primitivas geométricas Hay tres modos de dibujar los polígonos: GL_FILL (dibuja el polígono coloreado), GL_LINE (dibuja solo las aristas) y GL_POINTS (dibuja solo los vértices). Para asignar el modo se utiliza la función: glpolygonmode(glenum face, GLenum mode); El primer parámetro puede tomar los valores GL_FRONT, GL_BACK y GL_FRONT_AND_BACK. Se puede asignar diferentes modos a las dos caras de los polígonos. Por ejemplo glpolygonmode(gl_front, GL_FILL); glpolygonmode(gl_back, GL_LINES); 2
2.1 Primitivas geométricas Por defecto, OpenGL dibuja las primitivas en el orden en el que se definen, sin considerar su nivel de profundidad. Para considerar la profundidad, dibujando las superficies más cercanas encima de las más alejadas, es necesario activar esta opción con la función glenable(gl_depth_test). Esta opción activa el uso del buffer de profundidad. En este buffer se almacena la profundidad de los píxeles de los diferentes pixel fragments. Para borrar el contenido del buffer de profundidad se utiliza la función glclear(gl_depth_buffer_bit). La constante es una máscara, de manera que se pueden borrar varios buffers en una llamada: glclear(gl_color_buffer_bit GL_DEPTH_BUFFER_BIT); 21
2.1 Primitivas geométricas Una técnica sencilla de aceleración gráfica consiste en no dibujar los polígonos que vemos por su cara trasera. Para activar esta técnica se utiliza la función: glenable(gl_cull_face); 22
2.1 Primitivas geométricas Al igual que se puede asignar un patron de intermitencia en las líneas, también es posible asignar un patrón de dibujo en los polígonos. Un patrón bidimensional es una array de 32x32 bits. Para representarlo se usa una lista de 128 bytes sin signo (GLubyte) que describen las filas de bits de abajo a arriba. Para activar el uso de patrones sobre los polígonos se usa glenable(gl_polygon_stipple); glpolygonstipple(pattern); 23
2.1 Primitivas geométricas GLubyte fly[] = { x, x, x, x, x, x, x, x, x3, x8, x1, xc, x6, xc, x3, x6, x4, x6, x6, x2, x4, x3, xc, x2, x4, x18, x18, x2, x4, xc, x3, x2, x4, x6, x6, x2, x44, x3, xc, x22, x44, x1, x8, x22, x44, x1, x8, x22, x44, x1, x8, x22, x44, x1, x8, x22, x44, x1, x8, x22, x44, x1, x8, x22, x66, x1, x8, x66, x33, x1, x8, xcc, x19, x81, x81, x98, xc, xc1, x83, x3, x7, xe1, x87, xe, x3, x3f, xfc, xc, x3, x31, x8c, xc, x3, x33, xcc, xc, x6, x64, x26, x6, xc, xcc, x33, x3, x18, xcc, x33, x18, x1, xc4, x23, x8, x1, x63, xc6, x8, x1, x3, xc, x8, x1, x18, x18, x8, x1, x, x, x8}; 24
2.1 Primitivas geométricas Otra forma de acelerar el proceso de dibujo consiste en actualizar sólo la parte de la imagen que ha sufrido cambios. OpenGL permite indicar la zona rectangular que debe ser actualizada. Por defecto esta zona corresponde al viewport completo. Para activar el uso de áreas recortadas se utiliza la función glenable(gl_scissor_test). Una vez activada la opción, el área recortada se define por medio de la función glscissor(orig_x,orig_y, width, height), que toma como argumentos las coordenadas en pixeles de la esquina inferior izquierda y la anchura y altura del área. 25
Índice 2.1 Primitivas geométricas 2.2 Transformaciones geométricas 2.3 Proyecciones 26
2.2 Transformaciones geométricas Para generar una imagen del modelo 3D es necesario transformar la posición de cada vértice en la posición de un pixel dentro de la imagen renderizada. Para calcular esta transformación es necesario realizar un conjunto de operaciones que se conoce como el pipeline de transformación de vértices. La información original de un vértice se almacena como un vector de 4 componentes (x,y,z,w). La última componente representa un factor de escala (que por defecto es 1.). v x y z w 27
2.2 Transformaciones geométricas La primera transformación consiste en adaptar las coordenadas del vértice al sistema de coordenadas del observador. Las nuevas coordenadas se obtienen multiplicando el vector original por una matriz (denominada ModelView) que realiza las operaciones de rotación, traslación y escalado necesarias para modificar el sistema de coordenadas x y z w e e e e a a a a 1 2 3 a a a a 1 11 21 31 a a a a 2 12 22 32 a a a a 3 13 23 33 x y z w 28
2.2 Transformaciones geométricas La segunda transformación consiste en realizar la proyección (ortográfica o en perspectiva), que transforma el clipping volume en un volumen cúbico normalizado entre las coordenadas (-1,-1,-1) y (1,1,1). Las nuevas coordenadas se obtienen multiplicando el vector por la matriz de proyección (denominada Projection). x y z w c c c c p p p p 1 2 3 p p p p 1 11 21 31 p p p p 2 12 22 32 p p p p 3 13 23 33 x y z w e e e e 29
2.2 Transformaciones geométricas La siguiente transformación consiste en dividir todas las coordenadas por el factor de escala, obteniendo un vector de tres dimensiones. x y z n n n x y z c c c w w w c c c Por último, las coordenadas x n e y n (definidas como números reales entre -1 y 1) se transforman en coordenadas de píxeles (números enteros) y la coordenada z n se almacena como nivel de profundidad del vértice. 3
2.2 Transformaciones geométricas El proceso anterior viene determinado por el contenido de dos matrices (de modelado y de proyección). OpenGL contiene funciones que permiten modificar el contenido de las matrices, pero antes de utilizarlas es preciso indicar sobre cual de las dos matrices estamos trabajando. Para trabajar sobre el posicionamiento de los vértices en el modelo (es decir, para definir las primitivas geométricas) hay que activar el modo GL_MODELVIEW.: glmatrixmode(gl_modelview); Para configurar el proceso de proyección hay que activar el modo GL_PROJECTION: glmatrixmode(gl_projection); 31
2.2 Transformaciones geométricas Cuando definimos un vértice, la posición real del punto no es la que indicamos en la definición sino el resultado de multiplicar ese vector de posición por la matriz MODELVIEW. V real = M V definición Para que este proceso no modifique la posición del vértice, la matriz modelview debe ser la unidad. Para asignar la matriz unidad se utiliza la función: glloadidentity(); 1 1 M 1 1 32
2.2 Transformaciones geométricas Si queremos que realizar una traslación sobre el modelo, la matriz debe ser De esta forma 33 1 1 1 1 c b a M Tr 1 1 1 1 1 1 c z b y a x z y x c b a v M v Tr e
2.2 Transformaciones geométricas Para modificar la matriz modelview añadiendo una traslación se utiliza la función gltranslatef(glfloat a, GLfloat b, GLfloat c); gltranslated(gldouble a, GLdouble b, GLdouble c); Esta función genera una modificación de la matriz modelview: M new M old M Tr 34
2.2 Transformaciones geométricas Si queremos que realizar una transformación de escalado sobre el modelo, la matriz debe ser De esta forma 35 1 c b a M Sc 1 1 1 z c y b x a z y x c b a v M v Sc e
2.2 Transformaciones geométricas Para modificar la matriz modelview añadiendo una transformación de escalado se utiliza la función glscalef(glfloat a, GLfloat b, Glfloat c); glscaled(gldouble a, GLdouble b, GLdouble c); Esta función genera una modificación de la matriz modelview: M new M old M Sc 36
2.2 Transformaciones geométricas Las rotaciones afectan a las tres primeras filas y columnas de la matriz. Por ejemplo, para girar un ángulo α sobre el eje Z la matriz debe ser De esta forma 37 1 1 ) cos( ) sin( ) sin( ) cos( M Rot 1 ) cos( ) sin( ) sin( ) cos( 1 1 1 ) cos( ) sin( ) sin( ) cos( z y x y x z y x v M v Rot e
2.2 Transformaciones geométricas En general, para realizar una rotación alrededor de una cierta dirección es necesario una matriz 3x3 con determinante 1. Para modificar la matriz modelview incluyendo una rotación sobre una determinada dirección se utiliza la función glrotatef(glfloat angle, GLfloat x, GLfloat y, GLfloat z); glrotated(gldouble angle, GLdouble x, GLdouble y, GLdouble z); Los valores (x,y,z) determinan una dirección. OpenGL normaliza estos valores para construir un vector unitario. Esta función genera una modificación de la matriz modelview: M new M old M Rot 38
2.2 Transformaciones geométricas Las transformaciones geométricas (traslaciones, rotaciones y escalado) sirven tanto para situar los elementos como para situar al observador. (Esta es la razón por la que la matriz se denomina modelview). Por ejemplo, una traslación del observador hacia atrás (desplazamiento en dirección Z positiva) es equivalente a una traslación del modelo hacia adelante (desplazamiento en dirección Z negativa) manteniendo al observador en el origen de coordenadas. 39
2.2 Transformaciones geométricas Para calcular la posición en la que se transforma un determinado vértice hay que leer las transformaciones en sentido inverso. Por ejemplo, si disponemos de una función RenderSquare() que dibuja un cuadrado de lado 1 situado sobre el plano Z= y centrado en el origen de coordenadas y queremos dibujar un cuadrado de lado dos, situado en el plano Y= y centrado en el punto (1,,-1) Y Y Z X Z X 4
2.2 Transformaciones geométricas Hay que: 1. Escalar el cuadrado con un factor 2 2. Rotarlo 9º respecto al eje Y 3. Desplazarlo hasta la posición (1,,-1) Para realizar estas transformaciones hay que multiplicar así: v e M M Rot M Por lo que la secuencia de funciones debe ser Tr Sc v gltranslatef(1.f,.f, -1.f); glrotatef(3.1416f/2,.f, 1.f,.f); glscalef(2.f,2.f,2.f); RenderSquare(); 41
2.2 Transformaciones geométricas Las llamadas sucesivas a las funciones de transformación provocan que OpenGL realice numerosas multiplicaciones entre matrices. Si conocemos el contenido deseado para la matriz, es posible asignar su valor directamente mediante la función glloadmatrixf(glfloat *m) M m[] m[1] m[2] m[3] m[4] m[5] m[6] m[7] m[8] m[9] m[1] m[11] m[12] m[13] m[14] m[15] 42
2.2 Transformaciones geométricas También es posible asignar la matriz a partir de un array ordenado por filas en lugar de por columnas. Para ello se utiliza la función glloadtransposematrixf(glfloat *m) M m[] m[4] m[8] m[12] m[1] m[5] m[9] m[13] m[2] m[6] m[1] m[14] m[3] m[7] m[11] m[15] Si en lugar de asignar el valor de la matriz lo que conocemos es la representación de las transformaciones que deseamos realizar, se pueden utilizar las funciones glmultmatrixf(glfloat *m) glmulttransposematrixf(glfloat *m) 43
2.2 Transformaciones geométricas Generalmente, al incluir una serie de objetos en el modelo es necesario modificar la matriz modelview para colocar el objeto en la posición y orientación deseadas. Una vez definido el objeto es deseable volver a la configuración inicial de la matriz modelview. Para poder guardar el estado de la matriz modelview y recuperar dicho estado posteriormente, OpenGL dispone de una pila de matrices. Para almacenar el valor de la matriz se ejecuta la función glpushmatrix(). Para recuperar el último valor almacenado de la matriz se ejecuta la función glpopmatrix(). 44
Índice 2.1 Primitivas geométricas 2.2 Transformaciones geométricas 2.3 Proyecciones 45
2.3 Proyecciones Como ya hemos comentado, la segunda etapa del proceso de tratamiento de los vértices consiste en transformar el clipping volume en un volumen cúbico normalizado entre las coordenadas (-1,-1,-1) y (1,1,1). Esta etapa se denomina proyección. Una vez proyectado un vértice es muy fácil verificar si se encuentra o no en el clipping volume ya que solo hay que verificar si sus coordenadas transformadas es encuentran en los intervalos [-1, 1]. Existen dos formas de realizar esta transformación: mediante una proyección ortográfica o mediante una proyección en perspectiva. 46
2.3 Proyecciones Proyección ortográfica: glmatrixmode(gl_projection); glloadidentity(); glortho(l,r,b,t,n,f); 47
2.3 Proyecciones Proyección ortográfica La matriz de proyección que genera la función glortho() es la siguiente: 48 1 2 2 2 n f n f n f b t b t b t l r l r l r P
2.3 Proyecciones Proyección ortográfica Si el clipping volume es simétrico (r = -l y t = -b) la matriz queda 49 1 2 1 1 n f n f n f t r P
2.3 Proyecciones Proyección en perspectiva: glmatrixmode(gl_projection); glloadidentity(); glfrustum(l,r,b,t,n,f); 5
2.3 Proyecciones Proyección en perspectiva La matriz de proyección que genera la función glfrustum() es la siguiente: 51 1 2 2 2 n f n f n f f b n t b t b t n l r l r l r n P
2.3 Proyecciones Proyección en perspectiva Si el clipping volume es simétrico (r = -l y t = -b) la matriz queda 52 1 2 n f n f n f n f t n r n P