Arreglos de vértices

Tamaño: px

Comenzar la demostración a partir de la página:

Download "Arreglos de vértices"

Pedro Robles Jiménez
hace 6 años
Vistas:

1 Arreglos de vértices En lugar de que se especifiquen datos individuales del vértice en el modo inmediato (entre los pares glbegin() y glend()), es posible almacenar datos en un conjunto de arreglos incluyendo coordenadas del vértice, normales, coordenadas de textura y la información del color. Podemos dibujar primitivas geométricos diferenciando los elementos del arreglo con los índices. Observemos el siguiente código siguiente para dibujar un cubo con el modo inmediato. Cada cara necesita 4 veces la llamada de glvertex* () para formar un cuadrado, por ejemplo, el cuadrado en el frente es v0-v1-v2-v3. Un cubo tiene 6 caras, así que el número total de llamadas de glvertex* () es 24. Si también se especifican las normales y colores a los correspondientes vértices, el número de llamadas a la función aumenta 3 veces más; 24 a glcolor* () y 24 a glnormal* (). La otra cosa que debemos notar es el vértice v0 que se comparte con 3 polígonos adyacentes; cara frontal, derecha y la de arriba. En modo inmediato, se tiene que proporcionar el vétrice compartido 3 veces, una vez para cada cara según las indicaciones del código. glbegin(gl_quads); // dibuja un cubo con 6 cuadrados glvertex3fv(v0); // cara frontal glvertex3fv(v1); glvertex3fv(v2); glvertex3fv(v3); glvertex3fv(v0); glvertex3fv(v3); glvertex3fv(v4); glvertex3fv(v5); glvertex3fv(v0); glvertex3fv(v5); glvertex3fv(v6); glvertex3fv(v1); // cara derecha // cara de arriba // dibuja las otras 3 caras glend();

2 Usando arreglos de vértices se reduce el número de llamadas a la función y el uso redundante de vértices compartidos. Por lo tanto, se puede aumentar el desempeño del renderizado. Se tienen 3 diferentes funciones de OpenGL que explican el uso de los arreglos de vértices; gldrawarrays(), gldrawelements() y gldrawrangeelements(). Aunque, un mejor enfoque es utilizar vertex buffer objects (VBO) o listas de despliegue. Inicialización OpenGL proporciona las funciones glenableclientstate() y gldisableclientstate() para activar y desactivar 6 diferentes tipos de arreglos. Es más, existens 6 funciones para especificar las posiciones exactas (direcciones) de los arreglos, así pues, OpenGL puede tener acceso a los arreglos en una aplicación. glvertexpointer(): especifica el apuntador a las coordenadas del arreglo del vértice glnormalpointer(): especifica el apuntador al arreglo de normales glcolorpointer(): especifica el apuntador al arreglo del color RGB glindexpointer(): especifica el apuntador al arreglo del color indexado gltexcoordpointer(): especifica el apuntador al arreglo de coordenadas de textura gledgeflagpointer(): especifica el apuntador al arreglo de las banderas del borde Cada función especifica requiere diversos parámetros. Para mayores detalles, se pueden consultar el manual de funciones OpenGL. Las banderas del borde se utilizan para marcar si el vértice está en el límite del borde o no. Por lo tanto, los únicos bordes donde están las banderas del borde serán visibles si el glpolygonmode() se fija con GL_LINE. Note que los arreglos de vértices están situados en la aplicación (memoria del sistema), es decir por parte del cliente. Y, OpenGL está en el lado del servidor permite el acceso a ellos. Es decir, hay comandos distintivos para el arreglo de vértices; glenableclientstate () y gldisableclientstate() en vez de usar glenable() y gldisable(). gldrawarrays() gldrawarrays() lee datos de vértices desde los arreglos habilitados. Ya que gldrawarrays() no permite saltos alrededor de los arreglos de vértices, todavía tienen que repetirse los vértices compartidos una vez por cara. gldrawarrays() toma 3 argumentos. La primera cosa es el tipo primitivo. El segundo parámetro es la compensación de inicio del arreglo. El último parámetro es el número de vértices a pasar a la tubería de renderizado de OpenGL. En el ejemplo anterior, para dibujar un cubo, el primer parámetro es GL_QUADS, el segundo es 0, lo que significa que es a partir del principio del arreglo. Y el último parámetro es 24: un cubo requiere 6 caras y cada cara necesita 4 vértices para construir un cuadrado, 6 4 = 24.

3 GLfloat vertices[] = {}; // 24 coordenadas de los vértices // activa y especifica el apuntado al arreglo de vértices // dibuja un cubo gldrawarrays(gl_quads, 0, 24); // desactiva el arreglo de vértices después de dibujar Como resultado de usar gldrawarrays(), se pueden substituir 24 llamadas a glvertex* () por una sola llamada de gldrawarrays(). Sin embargo, todavía necesitamos duplicar los vértices compartidos, así que el número de vértices definidos en el arreglo es 24 en vez de 8. gldrawelements() sigue siendo la solución para reducir el número de vértices en el arreglo, ya que permite transferir menos datos a OpenGL. gldrawelements() gldrawelements() dibuja una secuencia de primitivas saltando alrededor del arreglo de vértices con los índices asociados del arreglo. Reduce el número de llamadas de función y el número de vértices a transferir. Además, OpenGL puede depositar los vértices recientemente procesados y reutilizarlos sin el reenvío de los mismos vértices en el arreglo transformando la tubería muchas veces. gldrawelements() requiere 4 parámetros. El primero es el tipo de primitiva, el segundo es el número de índices del arreglo de índices, el tercero es tipo de datos del arreglo de índices y el último parámetro es la dirección del arreglo de índices. En este ejemplo, los parámetros son, GL_QUADS, 24, GL_UNSIGNED_BYTE y los índices respectivamente. GLfloat vertices[] = {}; // 8 de las coordenadas de los vértices GLubyte indices[] = {0,1,2,3, // 24 de los indices 0,3,4,5, 0,5,6,1, 1,6,7,2, 7,4,3,2, 4,7,6,5}; // activa y especifica el apuntador al arreglo de vértices // dibuja un cubo gldrawelements(gl_quads, 24, GL_UNSIGNED_BYTE, indices); // desactiva el arreglo de vértices después de dibujar

4 El tamaño del arreglo de las coordenadas de vértices ahora es 8, que es exactamente el mismo número de vértices en el cubo sin ninguna entrada redundante. Observe que el tipo de datos del arreglo de índices es GLubyte en vez de GLuint o de GLushort. Debe ser el tipo de datos más pequeño que puede caber en el número de índices máximo para reducir el tamaño del arreglo del índice, si no, puede causar un mal desempeño debido al tamaño del arreglo de índices. Puesto que el arreglo de vértices contiene 8 vértices, GLubyte es adecuado para almacenar todos los índices. Diferentes normales en un vértice compartido Otra cosa que debemos considerar es que los vectores normales en los vértices compartidos. Si las normales de los polígonos adyacentes en un vértice compartido son todos diferentes, entonces los vectores normales deben ser especificados de acuerdo al número de caras, una vez para cada cara. Por ejemplo, el vértice v0 se comparte con la cara frontal, la derecha y la de arriba, pero, las normales no se pueden compartir en v0. El normal de la cara delantera es n0, la normal de la cara derecha es n1 y la normal de la cara de arriba es n2. Para esta situación, la normal no es igual en un vértice compartido, el vértice no se puede definir solamente una vez en el arreglo de vértices. Debe ser definido múltiples veces en el arreglo para las coordenadas de los vértices para tener la misma cantidad de elementos en el arreglo de normales. gldrawrangeelements() Al igual que gldrawelements(), gldrawrangeelements() es también una buena opción para saltar alrededor del arreglo de vértices. Sin embargo, gldrawrangeelements() tiene dos parámetros más (el índice de inicio y final) para especificar un rango de vértices a ser preutilizados. Agregando esta restricción de un rango, OpenGL puede obtener solamente la cantidad limitada de datos del arreglo de vértices antes del renderizado, y puede aumentar el desempeño. Los parámetros adicionales en gldrawrangeelements() son el inicio y final del índice, entonces OpenGL preutiliza la cantidad limitada de vértices de estos valores: final - inicio + 1. Y los valores en el arreglo de índices deben estar entre el índice del inicio y el índice del final. Notemos que no todos los vértices en el rango (inicio, final) deben ser referenciados. Pero, si se especifica un rango escaso utilizado, este causa un proceso innecesario para muchos vértices no utilizados en ese rango.

5 GLfloat vertices[] = {}; // 8 de las coordenadas de vértices GLubyte indices[] = {0,1,2,3, // 24 de los índices 0,3,4,5, 0,5,6,1, 1,6,7,2, 7,4,3,2, 4,7,6,5}; // activa y especifica un apuntador al arreglo de vértices // dibuja una primera mitad, el rango es = 7 vertices gldrawrangeelements(gl_quads, 0, 6, 12, GL_UNSIGNED_BYTE, indices); // dibuja la segunda mitad, el rango es = 7 vertices gldrawrangeelements(gl_quads, 1, 7, 12, GL_UNSIGNED_BYTE, indices+12); // desactiva los arreglos de vertices despues de dibujar Es posible descubrir el número máximo de vértices a ser preutilizados y el número máximo de índices que serán referenciados usando glgetintegerv() con GL_MAX_ELEMENTS_VERTICES y GL_MAX_ELEMENTS_INDICES

Documentos relacionados

1 Representación por superficies de polígonos

1 Representación por superficies de polígonos 1 La representación de frontera que más se utiliza para un objeto gráfico tridimensional es un conjunto de polígonos de superficie que encierran el interior del objeto. Muchos sistemas gráficos almacenan