#include <mesh.h>
Diagrama de herencias de MESH
Métodos públicos | |
MESH (int threshold, BOOLEAN strips, BOOLEAN center_model, double scale) | |
La constructora de clase prepara un "objeto MESH nulo", y ademas configura flags por defecto (como la seleccion de cual de las 4 versiones de pintado OpenGL se usara). | |
virtual | ~MESH () |
La destructora de esta clase se encarga de liberar la memoria de todas las estructuras de datos dinamicas del modelo MESH. | |
void | anexar_textura (IMAGEN *img) |
int | clasificar_punto (VECTOR p) |
void | minmax (VECTOR *min, VECTOR *max) |
void | pintar_gl (CALIDAD_VISUAL *Calidad, MATERIAL *Material, CAMARA *Camara) |
Notese que este metodo llama una lista OpenGL previamente precompilada si es el caso, o escoje un algoritmo de visualizacion OpenGL especifico. | |
void | pintar_povray (FILE *fd) |
void | pintar_aqz (FILE *fd) |
void | init (void) |
Performs some model clean-up that can only be done once we have the entire model. | |
void | promediar_normales_vertice (void) |
Este metodo modifica las normales de modelos en los que se usan multiples vertices en un solo lugar, los cuales dan lugar a normales de vertice equivalentes a las normales de triangulo y que por ende, resultan en modelos que no son interpolados por modelos goroud, y parecen estar siempre planos. | |
void | anx_vertex (VERTICE_GL) |
void | anx_indice_tira (long int i) |
Inserta indices a vertice que se usaran para construir tiras. | |
void | anx_tira (void) |
Notese que esta operacion activa como tira al conjunto de indices de tira que han sido insertados desde la ultima ejecucion de esta primitiva... | |
void | anx_color (GLubyte r, GLubyte g, GLubyte b) |
void | anx_triangle (TRIANGULO_GL, char *nombre_material) |
Este metodo ingresa un nuevo triangulo a la estructura de datos, siempre y cuando los tres vertices del triangulo no sean colineales. | |
void | anx_material (COLOR, COLOR, COLOR, char *, char *, int) |
void | set_escala (double e) |
void | set_nombre_de_archivo (char *c) |
void | set_invertir_orden (BOOLEAN o) |
void | get_vertices (VERTICE_GL **V, long int *n) |
Este metodo permite que una entidad externa a la clase MESH manipule la geometria, al dar acceso de lectura/escritura al arreglo central de vertices. | |
BOOLEAN | importar_obj (char *archivo, double *Escala_optima) |
BOOLEAN | exportar_obj (FILE *fd, int i) |
Notese que esto exporta el i-esimo grupo gl. | |
void | set_pintado_normales (BOOLEAN c) |
long int | num_vertices (void) |
void | set_debug_vertices (BOOLEAN c) |
void | set_debug_vertices_index (long int i) |
long int | num_triangulos (void) |
void | set_debug_triangulos (BOOLEAN c) |
void | set_debug_triangulos_index (long int i) |
int | num_grupos (void) |
Este metodo reporta el numero de grupos de esta MESH. | |
void | controlar (BOOLEAN *arr_control) |
Este metodo recibe un arreglo de banderas, cuya longitud debe ser igual a `num_grupos()`. | |
void | imprimir (BOOLEAN full_report=TRUE) |
void | set_material_global (BOOLEAN m) |
void | set_debug_tiras (BOOLEAN t) |
Métodos privados | |
void | crear_trozos_gl (void) |
Crea una lista de vertices que puede ser usada como un arreglo tipo "vertex" en OpenGL. | |
void | crear_tiras (void) |
Este metodo utiliza la utilidad externa "stripe" para convertir cada uno de los trozos_gl en una lista de tiras de triangulos. | |
GLfloat | angulo_de_vertice (TRIANGULITO *, GLuint) |
Éste método calcula el ángulo que en el vértice `vertex` abarca el extremo del triangulo `triangle`. | |
void | calcule_normales_vertice (void) |
Generate the per-vertex normals. | |
void | cree_lista_de_referencias (void) |
Build links from the vertices back to the polygon lists. | |
void | anexar_trozo_obj (char *linea) |
OJO:. | |
int | encontrar_material (char *) |
BOOLEAN | calcule_normal_triangulo (TRIANGULITO *Triangulo) |
Retorna TRUE si todo esta bien, o FALSE si el triangulo es un "degenerado" Returns the normal for the triangle (not a vertex normal, but a surface normal). | |
void | pintar_triangulos_gl (CALIDAD_VISUAL *Calidad) |
Visualiza la estructura de datos en OpenGL utilizando el arreglo de vertices en modo de lista de triangulos. | |
void | pintar_triangulos_tira_gl (CALIDAD_VISUAL *Calidad) |
Esta es la version no-recomendada de la mas eficiente pintar_triangulosv_tira_gl, para ofrecer compatibilidad con implementaciones OpenGL 1.0. | |
void | pintar_triangulosv_gl (CALIDAD_VISUAL *Calidad) |
Visualiza la estructura de datos en OpenGL utilizando el arreglo de vertices en modo de lista de triangulos. | |
void | pintar_triangulosv_tira_gl (CALIDAD_VISUAL *Calidad) |
void | compilar_lista_gl (int lista_gl, CALIDAD_VISUAL *Calidad) |
Aqui se selecciona un algoritmo de visualizacion particular de entre los 4 disponibles (al igual que `nucleo_pintar_gl`) y se ejecuta como parte de la compilacion de una lista OpenGL. | |
void | nucleo_pintar_gl (CALIDAD_VISUAL *Calidad) |
La clase `MESH` posee 4 versiones de pintado OpenGL (triangulos o tiras de triangulos, tanto usando un lista GL o sin ella). | |
void | pintar_debug_vertice (long int i) |
void | pintar_debug_triangulo (long int i) |
Atributos privados | |
ARREGLO< VERTICE_GL > | arr_vertices |
ARREGLO< TROZO_GL > | arr_trozos_gl |
ARREGLO< GLubyte > | arr_colores |
ARREGLO< TRIANGLENODE * > | listas_de_referencias |
VERTICE_GL | vertice_promedio |
GLfloat | cos_threshold |
double | escala |
IMAGEN * | imagen |
char * | _nombre_de_archivo |
VECTOR | _min |
VECTOR | _max |
long int | ultima_tira |
BOOLEAN | _invertir_orden |
BOOLEAN | con_lista_gl |
BOOLEAN | calcular_normales |
BOOLEAN | centrar_modelo |
BOOLEAN | preservar_bordes |
BOOLEAN | normales_de_triangulo |
BOOLEAN | modo_tiras_de_triangulos |
BOOLEAN | preprocesada |
BOOLEAN | con_minmax |
int | id_lista_opengl |
BOOLEAN | preprocesada_gl |
BOOLEAN | pintar_normales |
BOOLEAN * | Arr_control |
BOOLEAN | pintar_debug_vertices |
long int | index_debug_vertice |
BOOLEAN | pintar_debug_triangulos |
long int | index_debug_triangulo |
BOOLEAN | material_global |
BOOLEAN | mostrar_tiras |
|
La constructora de clase prepara un "objeto MESH nulo", y ademas configura flags por defecto (como la seleccion de cual de las 4 versiones de pintado OpenGL se usara). Notese que algunos flags se configuran mediante parametros de la constructora.
OJO: El umbral es entre 0 y 90? o entre 0 y 180? Definición en la línea 120 del archivo mesh.C. References _invertir_orden, _nombre_de_archivo, Arr_control, calcular_normales, centrar_modelo, con_lista_gl, con_minmax, cos_threshold, escala, GLfloat, imagen, index_debug_triangulo, index_debug_vertice, material_global, modo_tiras_de_triangulos, mostrar_tiras, normales_de_triangulo, pintar_debug_triangulos, pintar_debug_vertices, pintar_normales, preprocesada, preprocesada_gl, preservar_bordes, ultima_tira, vertice_promedio, VERTICE_GL::x, VERTICE_GL::y, y VERTICE_GL::z. |
|
La destructora de esta clase se encarga de liberar la memoria de todas las estructuras de datos dinamicas del modelo MESH.
Definición en la línea 192 del archivo mesh.C. References _nombre_de_archivo, arr_trozos_gl, arr_vertices, ARREGLO< TRIANGLENODE * >::elim(), ARREGLO< TROZO_GL >::elim(), ARREGLO< VERTICE_GL >::elim(), listas_de_referencias, y ARREGLO< TROZO_GL >::tam(). |
Here is the call graph for this function:
|
Implements GEOMETRIA. Definición en la línea 1011 del archivo mesh.C. References imagen. Referenciado por LECTOR_QUAKE_MD2::exportar_MESH(), y TELA::leer_malla(). |
|
OJO:. Importar archivos obj presenta un problema grave: y es que obj es una MESH que no solo contiene triangulos sino cualquier poligono... otro problema es que las normales estan asociadas a los poligonos y no a los vertices... Es normal que esto no funcione muy bien... Para arreglarlo es bueno que la entrada venga en triangulos... o mejor aun, cada que se detecte un poligono de entrada de 4 o mas lados en este algoritmo deberia triangularizarse... Definición en la línea 1418 del archivo mesh.C. References LISTA< T >::anx(), anx_triangle(), LISTA< T >::elim(), TRIANGULO_GL::p0, TRIANGULO_GL::p1, TRIANGULO_GL::p2, y LISTA< T >::tam(). Referenciado por importar_obj(). |
Here is the call graph for this function:
|
Éste método calcula el ángulo que en el vértice `vertex` abarca el extremo del triangulo `triangle`. Se utiliza la fórmula de la ley de los cosenos (una forma genérica del teorema de Pitágoras):
Definición en la línea 271 del archivo mesh.C. References arr_vertices, GLfloat, TRIANGULITO::p0, TRIANGULITO::p1, y TRIANGULITO::p2. Referenciado por calcule_normales_vertice(). |
|
Definición en la línea 936 del archivo mesh.C. References ARREGLO< GLubyte >::anx(), y arr_colores. |
Here is the call graph for this function:
|
Inserta indices a vertice que se usaran para construir tiras.
Definición en la línea 894 del archivo mesh.C. References ARREGLO< TROZO_GL >::anx(), y arr_trozos_gl. Referenciado por ESCENA_VTK::leer_tiras(). |
Here is the call graph for this function:
|
Definición en la línea 985 del archivo mesh.C. References ARREGLO< TROZO_GL >::anx(), arr_trozos_gl, TROZO_GL::material, MATERIAL::set_ambiente(), MATERIAL::set_difusa(), MATERIAL::set_doble_cara(), MATERIAL::set_emision(), MATERIAL::set_especular(), MATERIAL::set_nombre(), MATERIAL::set_transparencia(), y TROZO_GL::texturename. Referenciado por LECTOR_QUAKE_MD2::exportar_MESH(), importar_3DS(), importar_obj(), TELA::leer_malla(), y ESCENA_VTK::leer_tiras(). |
Here is the call graph for this function:
|
Notese que esta operacion activa como tira al conjunto de indices de tira que han sido insertados desde la ultima ejecucion de esta primitiva...
Definición en la línea 903 del archivo mesh.C. References arr_trozos_gl, modo_tiras_de_triangulos, ARREGLO< TROZO_GL >::tam(), y ultima_tira. Referenciado por ESCENA_VTK::leer_tiras(). |
Here is the call graph for this function:
|
Este metodo ingresa un nuevo triangulo a la estructura de datos, siempre y cuando los tres vertices del triangulo no sean colineales.
Definición en la línea 944 del archivo mesh.C. References _invertir_orden, ARREGLO< TRIANGULITO >::anx(), TROZO_GL::arr_triangulos, arr_trozos_gl, arr_vertices, calcule_normal_triangulo(), encontrar_material(), TRIANGULITO::p0, TRIANGULO_GL::p0, TRIANGULITO::p1, TRIANGULO_GL::p1, TRIANGULITO::p2, TRIANGULO_GL::p2, y ARREGLO< VERTICE_GL >::tam(). Referenciado por anexar_trozo_obj(), LECTOR_QUAKE_MD2::exportar_MESH(), importar_3DS(), y TELA::leer_malla(). |
Here is the call graph for this function:
|
Definición en la línea 917 del archivo mesh.C. References ARREGLO< TRIANGLENODE * >::anx(), ARREGLO< VERTICE_GL >::anx(), arr_vertices, listas_de_referencias, vertice_promedio, VERTICE_GL::x, VERTICE_GL::y, y VERTICE_GL::z. Referenciado por calcule_normales_vertice(), LECTOR_QUAKE_MD2::exportar_MESH(), importar_3DS(), importar_obj(), TELA::leer_malla(), y ESCENA_VTK::leer_puntos(). |
Here is the call graph for this function:
|
Retorna TRUE si todo esta bien, o FALSE si el triangulo es un "degenerado" Returns the normal for the triangle (not a vertex normal, but a surface normal).
Definición en la línea 855 del archivo mesh.C. References arr_vertices, VECTOR::norma(), VECTOR::normalizar(), TRIANGULITO::nx, TRIANGULITO::ny, TRIANGULITO::nz, TRIANGULITO::p0, TRIANGULITO::p1, TRIANGULITO::p2, VECTOR::producto_cruz(), VECTOR::x, VECTOR::y, y VECTOR::z. Referenciado por anx_triangle(). |
Here is the call graph for this function:
|
Generate the per-vertex normals. Make new vertices if two surfaces are more than a threshold angle apart. Thus, a cube would have six surface normals but if the threshold was 90 degrees, it would have 24 vertex/normal pairs. Definición en la línea 319 del archivo mesh.C. References angulo_de_vertice(), anx_vertex(), arr_trozos_gl, arr_vertices, BOOLEAN, centrar_modelo, cos_threshold, GLfloat, GLuint, listas_de_referencias, normales_de_triangulo, TRIANGULITO::nx, TRIANGULITO::ny, TRIANGULITO::nz, TRIANGULITO::p0, TRIANGULITO::p1, TRIANGULITO::p2, preservar_bordes, TRIANGLENODE::sig, ARREGLO< TROZO_GL >::tam(), ARREGLO< VERTICE_GL >::tam(), TRIANGLENODE::triangle, vertice_promedio, VERTICE_GL::x, VERTICE_GL::y, y VERTICE_GL::z. Referenciado por init(). |
Here is the call graph for this function:
|
Implements GEOMETRIA. |
|
Aqui se selecciona un algoritmo de visualizacion particular de entre los 4 disponibles (al igual que `nucleo_pintar_gl`) y se ejecuta como parte de la compilacion de una lista OpenGL. Notese que este metodo se puede llamar sin problema alguno en modo de no usar listas GL, porque en ese caso no se hace nada. Definición en la línea 591 del archivo mesh_gl.C. References con_lista_gl, modo_tiras_de_triangulos, pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), y pintar_triangulosv_tira_gl(). Referenciado por pintar_gl(). |
Here is the call graph for this function:
|
Este metodo recibe un arreglo de banderas, cuya longitud debe ser igual a `num_grupos()`. Cuando la MESH esta "controlada", solo los grupos cuyo valor correspondiente en `Arr_control` sea TRUE seran pintados. Definición en la línea 1183 del archivo mesh.C. References Arr_control, y preprocesada_gl. |
|
Este metodo utiliza la utilidad externa "stripe" para convertir cada uno de los trozos_gl en una lista de tiras de triangulos. Esta operacion toma tiempo, pero usualmente mejora el desempenno grafico. PRE: "stripe" debe estar instalado en el sistema. Definición en la línea 722 del archivo mesh.C. References ARREGLO< TROZO_GL >::anx(), arr_trozos_gl, arr_vertices, BOOLEAN, con_minmax, exportar_obj(), GLuint, ARREGLO< VERTICE_GL >::tam(), y ARREGLO< TROZO_GL >::tam(). Referenciado por init(). |
Here is the call graph for this function:
|
Crea una lista de vertices que puede ser usada como un arreglo tipo "vertex" en OpenGL. ----------------------------------------------------------------------------- Make a list of triangle indexes for OpenGL's vertex arrays. This does not produce the more optimized TRIANGLE_STRIPS. Definición en la línea 643 del archivo mesh.C. References arr_trozos_gl, arr_vertices, GLuint, VECTOR::producto_cruz(), VECTOR::producto_punto(), ARREGLO< TROZO_GL >::tam(), VECTOR::x, VECTOR::y, y VECTOR::z. Referenciado por init(). |
Here is the call graph for this function:
|
Build links from the vertices back to the polygon lists. This sample code traverses the list we just made here: j = 0; for ( i = 0; i < arr_vertices.tam(); i++ ) { for ( qtr = listas_de_referencias[i]; qtr; qtr=qtr->sig) { j++; } } Definición en la línea 465 del archivo mesh.C. References arr_trozos_gl, listas_de_referencias, TRIANGULITO::p0, TRIANGULITO::p1, TRIANGULITO::p2, TRIANGLENODE::sig, ARREGLO< TROZO_GL >::tam(), y TRIANGLENODE::triangle. Referenciado por init(). |
Here is the call graph for this function:
|
Definición en la línea 829 del archivo mesh.C. References arr_trozos_gl, y ARREGLO< TROZO_GL >::tam(). Referenciado por anx_triangle(). |
Here is the call graph for this function:
|
Notese que esto exporta el i-esimo grupo gl. Se escribe en `fd` informacion de mesh codificada en formato OBJ de Wavefront. Definición en la línea 1391 del archivo mesh.C. References arr_trozos_gl, arr_vertices, ARREGLO< TROZO_GL >::tam(), y ARREGLO< VERTICE_GL >::tam(). Referenciado por crear_tiras(). |
Here is the call graph for this function:
|
Este metodo permite que una entidad externa a la clase MESH manipule la geometria, al dar acceso de lectura/escritura al arreglo central de vertices. Notese que la topologia es opaca, en caso de querer cambiarla debe borrarse el objeto actual y crear uno nuevo. OJO: Esta molestando cuando se usan listas OpenGL... y por eso se ha desactivado. Definición en la línea 227 del archivo mesh.C. References arr_vertices, con_lista_gl, ARREGLO< VERTICE_GL >::data(), y ARREGLO< VERTICE_GL >::tam(). Referenciado por LECTOR_QUAKE_MD2::init(), ESCENA_VTK::leer_pd(), y TELA::pintar_gl(). |
Here is the call graph for this function:
|
Definición en la línea 1507 del archivo mesh.C. References COLOR::alpha, anexar_trozo_obj(), anx_material(), anx_vertex(), arr_vertices, COLOR::b, calcular_normales, COLOR::g, VECTOR::norma(), VECTOR::normalizar(), COLOR::r, MATRIZ_4x4::rotacion_angulos_euler(), set_nombre_de_archivo(), ARREGLO< VERTICE_GL >::tam(), VERTICE_GL::x, VECTOR::x, VERTICE_GL::y, VECTOR::y, VERTICE_GL::z, y VECTOR::z. |
Here is the call graph for this function:
|
Definición en la línea 1254 del archivo mesh.C. References _nombre_de_archivo, Arr_control, arr_trozos_gl, con_lista_gl, init(), modo_tiras_de_triangulos, num_vertices(), preprocesada, y ARREGLO< TROZO_GL >::tam(). |
Here is the call graph for this function:
|
Performs some model clean-up that can only be done once we have the entire model. This includes finding the vertex normals (instead of the polygon normals we already calculated), centering the object around 0,0,0, crunching the vertex data into vertex arrays for OpenGL, and compiling the display list. Note that this code finds the vertex normals by first calculating the angle that each polygon shares with that vertex. It then averages all the normals together, each one weighted on how much of an angle they contribute to the vertex. Also, if the user specified a threshold for normals so that surface edges are preserved, we have to add a new vertex to the list with the same X,Y,Z coordinates but different normal coordinates. Thus, edge preservation may look good, but it's expensive. OJO: Notese que sin la depuracion esto hace simplemente int i, acum_triangulos = 0; if ( calcular_normales ) { cree_lista_de_referencias(); calcule_normales_vertice(); } if ( modo_tiras_de_triangulos ) crear_tiras(); else crear_trozos_gl(); for ( i = 0; i < arr_trozos_gl.tam(); i++ ) { acum_triangulos += arr_trozos_gl[i].arr_triangulos.tam(); } preprocesada = TRUE; Definición en la línea 514 del archivo mesh.C. References arr_trozos_gl, arr_vertices, calcular_normales, calcule_normales_vertice(), crear_tiras(), crear_trozos_gl(), cree_lista_de_referencias(), modo_tiras_de_triangulos, preprocesada, preservar_bordes, ARREGLO< TROZO_GL >::tam(), ARREGLO< VERTICE_GL >::tam(), y ultima_tira. Referenciado por importar_3DS(), importar_VTK(), imprimir(), LECTOR_QUAKE_MD2::init(), TELA::leer_malla(), minmax(), TELA::pintar_gl(), pintar_gl(), y pintar_povray(). |
Here is the call graph for this function:
|
Reimplementado de GEOMETRIA. Definición en la línea 1024 del archivo mesh.C. References _max, _min, arr_trozos_gl, arr_vertices, con_minmax, escala, init(), modo_tiras_de_triangulos, preprocesada, ARREGLO< TROZO_GL >::tam(), VECTOR::x, VECTOR::y, y VECTOR::z. |
Here is the call graph for this function:
|
La clase `MESH` posee 4 versiones de pintado OpenGL (triangulos o tiras de triangulos, tanto usando un lista GL o sin ella). Esta funcion se encarga de seleccionar cual de las 4 versiones se usa. Notese que es llamada desde el front-end `pintar_gl`. Definición en la línea 631 del archivo mesh_gl.C. References con_lista_gl, id_lista_opengl, modo_tiras_de_triangulos, pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), y pintar_triangulosv_tira_gl(). Referenciado por pintar_gl(). |
Here is the call graph for this function:
|
Este metodo reporta el numero de grupos de esta MESH. Recuerde que cada grupo tiene su propio material. Definición en la línea 1155 del archivo mesh.C. References arr_trozos_gl, y ARREGLO< TROZO_GL >::tam(). |
Here is the call graph for this function:
|
Definición en la línea 1171 del archivo mesh.C. References arr_trozos_gl, y ARREGLO< TROZO_GL >::tam(). Referenciado por pintar_debug_triangulo(). |
Here is the call graph for this function:
|
Definición en la línea 1165 del archivo mesh.C. References arr_vertices, y ARREGLO< VERTICE_GL >::tam(). Referenciado por imprimir(), y ESCENA_VTK::leer_tiras(). |
Here is the call graph for this function:
|
Implements GEOMETRIA. |
|
Definición en la línea 454 del archivo mesh_gl.C. References num_triangulos(). Referenciado por pintar_gl(). |
Here is the call graph for this function:
|
Definición en la línea 374 del archivo mesh_gl.C. References MATERIAL::activar_gl(), arr_vertices, listas_de_referencias, TRIANGULITO::p0, TRIANGULITO::p1, TRIANGULITO::p2, ESFERA::pintar_gl(), MATERIAL::set_difusa(), MATERIAL::set_transparencia(), y ARREGLO< VERTICE_GL >::tam(). Referenciado por pintar_gl(). |
Here is the call graph for this function:
|
Here is the call graph for this function:
|
Implements GEOMETRIA. Definición en la línea 1096 del archivo mesh.C. References arr_trozos_gl, arr_vertices, escala, init(), preprocesada, y ARREGLO< TROZO_GL >::tam(). |
Here is the call graph for this function:
|
Visualiza la estructura de datos en OpenGL utilizando el arreglo de vertices en modo de lista de triangulos. Esta es la version no-recomendada de la mas eficiente pintar_triangulosv_gl, para ofrecer compatibilidad con implementaciones OpenGL 1.0. Definición en la línea 302 del archivo mesh_gl.C. References arr_colores, Arr_control, arr_trozos_gl, arr_vertices, ARREGLO< TROZO_GL >::tam(), ARREGLO< VERTICE_GL >::tam(), y ARREGLO< GLubyte >::tam(). Referenciado por compilar_lista_gl(), y nucleo_pintar_gl(). |
Here is the call graph for this function:
|
Esta es la version no-recomendada de la mas eficiente pintar_triangulosv_tira_gl, para ofrecer compatibilidad con implementaciones OpenGL 1.0.
Definición en la línea 501 del archivo mesh_gl.C. References MATERIAL::activar_gl(), arr_colores, Arr_control, arr_trozos_gl, arr_vertices, COLORES_tiras, GLuint, inicializar_ct(), MATERIAL_Global, mostrar_tiras, MATERIAL::set_difusa(), ARREGLO< VERTICE_GL >::tam(), ARREGLO< GLubyte >::tam(), y ARREGLO< TROZO_GL >::tam(). Referenciado por compilar_lista_gl(), y nucleo_pintar_gl(). |
Here is the call graph for this function:
|
Visualiza la estructura de datos en OpenGL utilizando el arreglo de vertices en modo de lista de triangulos. Notese que se este algoritmo requiere una implementacion OpenGL 1.1. o superior. Definición en la línea 464 del archivo mesh_gl.C. References arr_colores, Arr_control, arr_trozos_gl, arr_vertices, ARREGLO< GLubyte >::data(), ARREGLO< VERTICE_GL >::data(), ARREGLO< TROZO_GL >::tam(), ARREGLO< VERTICE_GL >::tam(), y ARREGLO< GLubyte >::tam(). Referenciado por compilar_lista_gl(), y nucleo_pintar_gl(). |
Here is the call graph for this function:
|
Definición en la línea 551 del archivo mesh_gl.C. References MATERIAL::activar_gl(), arr_colores, Arr_control, arr_trozos_gl, arr_vertices, COLORES_tiras, ARREGLO< GLubyte >::data(), ARREGLO< VERTICE_GL >::data(), inicializar_ct(), MATERIAL_Global, mostrar_tiras, MATERIAL::set_difusa(), ARREGLO< TROZO_GL >::tam(), ARREGLO< VERTICE_GL >::tam(), y ARREGLO< GLubyte >::tam(). Referenciado por compilar_lista_gl(), y nucleo_pintar_gl(). |
Here is the call graph for this function:
|
Este metodo modifica las normales de modelos en los que se usan multiples vertices en un solo lugar, los cuales dan lugar a normales de vertice equivalentes a las normales de triangulo y que por ende, resultan en modelos que no son interpolados por modelos goroud, y parecen estar siempre planos. Despues de aplicar este metodo, las normales de vertices que estan muy cerca se promedian dando lugar a una sola normal que se copia en todos esos vertices. El resultado es que se activa la interpolacion goroud. NOTA: NO se colapsan varios vertices en uno solo, porque pueden tener diferentes coordenadas de textura. Definición en la línea 584 del archivo mesh.C. References ARREGLO< T >::anx(), arr_vertices, VECTOR::normalizar(), ARREGLO< T >::tam(), ARREGLO< VERTICE_GL >::tam(), VECTOR::x, VECTOR::y, y VECTOR::z. Referenciado por LECTOR_QUAKE_MD2::init(). |
Here is the call graph for this function:
|
Definición en la línea 1245 del archivo mesh.C. References mostrar_tiras, y preprocesada_gl. |
|
Definición en la línea 1215 del archivo mesh.C. References pintar_debug_triangulos, y preprocesada_gl. |
|
Definición en la línea 1230 del archivo mesh.C. References index_debug_triangulo. |
|
Definición en la línea 1206 del archivo mesh.C. References pintar_debug_vertices, y preprocesada_gl. |
|
Definición en la línea 1224 del archivo mesh.C. References index_debug_vertice. |
|
Definición en la línea 265 del archivo mesh.C. References escala. |
|
Definición en la línea 253 del archivo mesh.C. References _invertir_orden. |
|
Definición en la línea 1236 del archivo mesh.C. References material_global, y preprocesada_gl. Referenciado por LECTOR_QUAKE_MD2::exportar_MESH(), y TELA::leer_malla(). |
|
Definición en la línea 259 del archivo mesh.C. References _nombre_de_archivo. Referenciado por importar_3DS(), importar_obj(), y importar_VTK(). |
|
Definición en la línea 1197 del archivo mesh.C. References pintar_normales, y preprocesada_gl. |
|
Definición en la línea 94 del archivo mesh.h. Referenciado por anx_triangle(), MESH(), y set_invertir_orden(). |
|
Definición en la línea 92 del archivo mesh.h. Referenciado por minmax(). |
|
Definición en la línea 91 del archivo mesh.h. Referenciado por minmax(). |
|
Definición en la línea 90 del archivo mesh.h. Referenciado por imprimir(), MESH(), set_nombre_de_archivo(), y ~MESH(). |
|
Definición en la línea 79 del archivo mesh.h. Referenciado por anx_color(), pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), y pintar_triangulosv_tira_gl(). |
|
Definición en la línea 112 del archivo mesh.h. Referenciado por controlar(), imprimir(), MESH(), pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), y pintar_triangulosv_tira_gl(). |
|
Definición en la línea 78 del archivo mesh.h. Referenciado por anx_indice_tira(), anx_material(), anx_tira(), anx_triangle(), calcule_normales_vertice(), crear_tiras(), crear_trozos_gl(), cree_lista_de_referencias(), encontrar_material(), exportar_obj(), imprimir(), init(), minmax(), num_grupos(), num_triangulos(), pintar_povray(), pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), pintar_triangulosv_tira_gl(), y ~MESH(). |
|
Definición en la línea 77 del archivo mesh.h. Referenciado por angulo_de_vertice(), anx_triangle(), anx_vertex(), calcule_normal_triangulo(), calcule_normales_vertice(), crear_tiras(), crear_trozos_gl(), exportar_obj(), get_vertices(), importar_obj(), init(), minmax(), num_vertices(), pintar_debug_vertice(), pintar_gl(), pintar_povray(), pintar_triangulos_gl(), pintar_triangulos_tira_gl(), pintar_triangulosv_gl(), pintar_triangulosv_tira_gl(), promediar_normales_vertice(), y ~MESH(). |
|
Definición en la línea 98 del archivo mesh.h. Referenciado por importar_obj(), init(), y MESH(). |
|
Definición en la línea 99 del archivo mesh.h. Referenciado por calcule_normales_vertice(), y MESH(). |
|
Definición en la línea 97 del archivo mesh.h. Referenciado por compilar_lista_gl(), get_vertices(), imprimir(), MESH(), y nucleo_pintar_gl(). |
|
Definición en la línea 104 del archivo mesh.h. Referenciado por crear_tiras(), MESH(), y minmax(). |
|
Definición en la línea 86 del archivo mesh.h. Referenciado por calcule_normales_vertice(), y MESH(). |
|
Definición en la línea 87 del archivo mesh.h. Referenciado por MESH(), minmax(), pintar_gl(), pintar_povray(), y set_escala(). |
|
Definición en la línea 106 del archivo mesh.h. Referenciado por nucleo_pintar_gl(), y pintar_gl(). |
|
Definición en la línea 89 del archivo mesh.h. Referenciado por anexar_textura(), MESH(), y pintar_gl(). |
|
Definición en la línea 116 del archivo mesh.h. Referenciado por MESH(), pintar_gl(), y set_debug_triangulos_index(). |
|
Definición en la línea 114 del archivo mesh.h. Referenciado por MESH(), pintar_gl(), y set_debug_vertices_index(). |
|
Definición en la línea 83 del archivo mesh.h. Referenciado por anx_vertex(), calcule_normales_vertice(), cree_lista_de_referencias(), pintar_debug_vertice(), y ~MESH(). |
|
Definición en la línea 117 del archivo mesh.h. Referenciado por MESH(), pintar_gl(), y set_material_global(). |
|
Definición en la línea 102 del archivo mesh.h. Referenciado por anx_tira(), compilar_lista_gl(), imprimir(), init(), MESH(), minmax(), y nucleo_pintar_gl(). |
|
Definición en la línea 118 del archivo mesh.h. Referenciado por MESH(), pintar_triangulos_tira_gl(), pintar_triangulosv_tira_gl(), y set_debug_tiras(). |
|
Definición en la línea 101 del archivo mesh.h. Referenciado por calcule_normales_vertice(), y MESH(). |
|
Definición en la línea 115 del archivo mesh.h. Referenciado por MESH(), pintar_gl(), y set_debug_triangulos(). |
|
Definición en la línea 113 del archivo mesh.h. Referenciado por MESH(), pintar_gl(), y set_debug_vertices(). |
|
Definición en la línea 111 del archivo mesh.h. Referenciado por MESH(), y set_pintado_normales(). |
|
Definición en la línea 103 del archivo mesh.h. Referenciado por imprimir(), init(), MESH(), minmax(), pintar_gl(), y pintar_povray(). |
|
Definición en la línea 107 del archivo mesh.h. Referenciado por controlar(), MESH(), pintar_gl(), set_debug_tiras(), set_debug_triangulos(), set_debug_vertices(), set_material_global(), y set_pintado_normales(). |
|
Definición en la línea 100 del archivo mesh.h. Referenciado por calcule_normales_vertice(), init(), y MESH(). |
|
Definición en la línea 93 del archivo mesh.h. Referenciado por anx_tira(), init(), y MESH(). |
|
Definición en la línea 85 del archivo mesh.h. Referenciado por anx_vertex(), calcule_normales_vertice(), y MESH(). |