Página principal | Jerarquía de la clase | Lista alfabética | Lista de componentes | Lista de archivos | Miembros de las clases | Archivos de los miembros | Páginas relacionadas

Referencia de la Clase MESH

#include <mesh.h>

Diagrama de herencias de MESH

Inheritance graph
[leyenda]
Diagrama de colaboración para MESH:

Collaboration graph
[leyenda]
Lista de todos los miembros.

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_GLarr_vertices
ARREGLO< TROZO_GLarr_trozos_gl
ARREGLO< GLubytearr_colores
ARREGLO< TRIANGLENODE * > listas_de_referencias
VERTICE_GL vertice_promedio
GLfloat cos_threshold
double escala
IMAGENimagen
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
BOOLEANArr_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

Documentación del constructor y destructor

MESH::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).

Notese que algunos flags se configuran mediante parametros de la constructora.

  • threshold: es un angulo umbral en grados (entre 0 y 90) para el algoritmo de generacion de normales de vertice adicionales (particion de vertices).
  • strips: si es TRUE esto utiliza el programa externo "stripe" para generar tiras de triangulos (acelerando la posterior visualizacion). Si es FALSE no hace nada. OJO: Asegurese de tener funcionando el programa "stripe" si usa esta opcion en TRUE.
  • center_model: si es TRUE alinea todos los vertices respecto al origen (mediante una translacion). Si es FALSE deja los vertices en su posicion original
  • scale: escala el modelo por este factor.

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.

MESH::~MESH void   )  [virtual]
 

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:


Documentación de las funciones miembro

void MESH::anexar_textura IMAGEN img  )  [virtual]
 

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().

void MESH::anexar_trozo_obj char *  linea  )  [private]
 

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:

GLfloat MESH::angulo_de_vertice TRIANGULITO triangle,
GLuint  vertex
[inline, private]
 

É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):

\[ c^2 = a^2 + b^2 + 2*a*b*cos(\theta) \]

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().

void MESH::anx_color GLubyte  r,
GLubyte  g,
GLubyte  b
 

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:

void MESH::anx_indice_tira long int  i  ) 
 

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:

void MESH::anx_material COLOR  ,
COLOR  ,
COLOR  ,
char *  ,
char *  ,
int 
 

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:

void MESH::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...

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:

void MESH::anx_triangle TRIANGULO_GL  tri,
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.

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:

void MESH::anx_vertex VERTICE_GL   ) 
 

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:

BOOLEAN MESH::calcule_normal_triangulo TRIANGULITO Triangulo  )  [private]
 

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:

void MESH::calcule_normales_vertice void   )  [private]
 

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:

int MESH::clasificar_punto VECTOR  p  )  [virtual]
 

Implements GEOMETRIA.

Definición en la línea 1018 del archivo mesh.C.

void MESH::compilar_lista_gl int  lista_gl,
CALIDAD_VISUAL Calidad
[private]
 

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:

void MESH::controlar BOOLEAN arr_control  ) 
 

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.

void MESH::crear_tiras void   )  [private]
 

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:

void MESH::crear_trozos_gl void   )  [private]
 

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:

void MESH::cree_lista_de_referencias void   )  [private]
 

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:

int MESH::encontrar_material char *   )  [private]
 

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:

BOOLEAN MESH::exportar_obj FILE *  fd,
int  i
 

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:

void MESH::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.

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:

BOOLEAN MESH::importar_obj char *  archivo,
double *  Escala_optima
 

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:

void MESH::imprimir BOOLEAN  full_report = TRUE  ) 
 

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:

void MESH::init void   ) 
 

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:

void MESH::minmax VECTOR min,
VECTOR max
[virtual]
 

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:

void MESH::nucleo_pintar_gl CALIDAD_VISUAL Calidad  )  [private]
 

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:

int MESH::num_grupos void   ) 
 

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:

long int MESH::num_triangulos void   ) 
 

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:

long int MESH::num_vertices void   ) 
 

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:

void MESH::pintar_aqz FILE *  fd  )  [virtual]
 

Implements GEOMETRIA.

Definición en la línea 1089 del archivo mesh.C.

void MESH::pintar_debug_triangulo long int  i  )  [private]
 

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:

void MESH::pintar_debug_vertice long int  i  )  [private]
 

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:

void MESH::pintar_gl CALIDAD_VISUAL Calidad,
MATERIAL Material,
CAMARA Camara
[virtual]
 

Notese que este metodo llama una lista OpenGL previamente precompilada si es el caso, o escoje un algoritmo de visualizacion OpenGL especifico.

Si se detecta algun cambio en la configuracion de la visualizacion la lista se recompila (si es necesaria). Todo el "trabajo sucio" se hace dentro de los metodos aqui seleccionados.

Implements GEOMETRIA.

Definición en la línea 659 del archivo mesh_gl.C.

References CALIDAD_VISUAL::activar_bordes_gl(), CALIDAD_VISUAL::activar_caras_gl(), IMAGEN::activar_gl(), CALIDAD_VISUAL::activar_textura_gl(), arr_vertices, compilar_lista_gl(), CALIDAD_VISUAL::con_bordes, CALIDAD_VISUAL::con_cajas, CALIDAD_VISUAL::con_caras, CALIDAD_VISUAL::con_caustics, CALIDAD_VISUAL::con_textura, escala, id_lista_opengl, imagen, index_debug_triangulo, index_debug_vertice, init(), material_global, MATERIAL_Global, nucleo_pintar_gl(), pintar_debug_triangulo(), pintar_debug_triangulos, pintar_debug_vertice(), pintar_debug_vertices, preprocesada, preprocesada_gl, y ARREGLO< VERTICE_GL >::tam().

Referenciado por TELA::pintar_gl().

Here is the call graph for this function:

void MESH::pintar_povray FILE *  fd  )  [virtual]
 

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:

void MESH::pintar_triangulos_gl CALIDAD_VISUAL Calidad  )  [private]
 

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:

void MESH::pintar_triangulos_tira_gl CALIDAD_VISUAL Calidad  )  [private]
 

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:

void MESH::pintar_triangulosv_gl CALIDAD_VISUAL Calidad  )  [private]
 

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:

void MESH::pintar_triangulosv_tira_gl CALIDAD_VISUAL Calidad  )  [private]
 

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:

void MESH::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.

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:

void MESH::set_debug_tiras BOOLEAN  t  ) 
 

Definición en la línea 1245 del archivo mesh.C.

References mostrar_tiras, y preprocesada_gl.

void MESH::set_debug_triangulos BOOLEAN  c  ) 
 

Definición en la línea 1215 del archivo mesh.C.

References pintar_debug_triangulos, y preprocesada_gl.

void MESH::set_debug_triangulos_index long int  i  ) 
 

Definición en la línea 1230 del archivo mesh.C.

References index_debug_triangulo.

void MESH::set_debug_vertices BOOLEAN  c  ) 
 

Definición en la línea 1206 del archivo mesh.C.

References pintar_debug_vertices, y preprocesada_gl.

void MESH::set_debug_vertices_index long int  i  ) 
 

Definición en la línea 1224 del archivo mesh.C.

References index_debug_vertice.

void MESH::set_escala double  e  ) 
 

Definición en la línea 265 del archivo mesh.C.

References escala.

void MESH::set_invertir_orden BOOLEAN  o  ) 
 

Definición en la línea 253 del archivo mesh.C.

References _invertir_orden.

void MESH::set_material_global BOOLEAN  m  ) 
 

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().

void MESH::set_nombre_de_archivo char *  c  ) 
 

Definición en la línea 259 del archivo mesh.C.

References _nombre_de_archivo.

Referenciado por importar_3DS(), importar_obj(), y importar_VTK().

void MESH::set_pintado_normales BOOLEAN  c  ) 
 

Definición en la línea 1197 del archivo mesh.C.

References pintar_normales, y preprocesada_gl.


Documentación de los datos miembro

BOOLEAN MESH::_invertir_orden [private]
 

Definición en la línea 94 del archivo mesh.h.

Referenciado por anx_triangle(), MESH(), y set_invertir_orden().

VECTOR MESH::_max [private]
 

Definición en la línea 92 del archivo mesh.h.

Referenciado por minmax().

VECTOR MESH::_min [private]
 

Definición en la línea 91 del archivo mesh.h.

Referenciado por minmax().

char* MESH::_nombre_de_archivo [private]
 

Definición en la línea 90 del archivo mesh.h.

Referenciado por imprimir(), MESH(), set_nombre_de_archivo(), y ~MESH().

ARREGLO<GLubyte> MESH::arr_colores [private]
 

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().

BOOLEAN* MESH::Arr_control [private]
 

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().

ARREGLO<TROZO_GL> MESH::arr_trozos_gl [private]
 

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().

ARREGLO<VERTICE_GL> MESH::arr_vertices [private]
 

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().

BOOLEAN MESH::calcular_normales [private]
 

Definición en la línea 98 del archivo mesh.h.

Referenciado por importar_obj(), init(), y MESH().

BOOLEAN MESH::centrar_modelo [private]
 

Definición en la línea 99 del archivo mesh.h.

Referenciado por calcule_normales_vertice(), y MESH().

BOOLEAN MESH::con_lista_gl [private]
 

Definición en la línea 97 del archivo mesh.h.

Referenciado por compilar_lista_gl(), get_vertices(), imprimir(), MESH(), y nucleo_pintar_gl().

BOOLEAN MESH::con_minmax [private]
 

Definición en la línea 104 del archivo mesh.h.

Referenciado por crear_tiras(), MESH(), y minmax().

GLfloat MESH::cos_threshold [private]
 

Definición en la línea 86 del archivo mesh.h.

Referenciado por calcule_normales_vertice(), y MESH().

double MESH::escala [private]
 

Definición en la línea 87 del archivo mesh.h.

Referenciado por MESH(), minmax(), pintar_gl(), pintar_povray(), y set_escala().

int MESH::id_lista_opengl [private]
 

Definición en la línea 106 del archivo mesh.h.

Referenciado por nucleo_pintar_gl(), y pintar_gl().

IMAGEN* MESH::imagen [private]
 

Definición en la línea 89 del archivo mesh.h.

Referenciado por anexar_textura(), MESH(), y pintar_gl().

long int MESH::index_debug_triangulo [private]
 

Definición en la línea 116 del archivo mesh.h.

Referenciado por MESH(), pintar_gl(), y set_debug_triangulos_index().

long int MESH::index_debug_vertice [private]
 

Definición en la línea 114 del archivo mesh.h.

Referenciado por MESH(), pintar_gl(), y set_debug_vertices_index().

ARREGLO<TRIANGLENODE *> MESH::listas_de_referencias [private]
 

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().

BOOLEAN MESH::material_global [private]
 

Definición en la línea 117 del archivo mesh.h.

Referenciado por MESH(), pintar_gl(), y set_material_global().

BOOLEAN MESH::modo_tiras_de_triangulos [private]
 

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().

BOOLEAN MESH::mostrar_tiras [private]
 

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().

BOOLEAN MESH::normales_de_triangulo [private]
 

Definición en la línea 101 del archivo mesh.h.

Referenciado por calcule_normales_vertice(), y MESH().

BOOLEAN MESH::pintar_debug_triangulos [private]
 

Definición en la línea 115 del archivo mesh.h.

Referenciado por MESH(), pintar_gl(), y set_debug_triangulos().

BOOLEAN MESH::pintar_debug_vertices [private]
 

Definición en la línea 113 del archivo mesh.h.

Referenciado por MESH(), pintar_gl(), y set_debug_vertices().

BOOLEAN MESH::pintar_normales [private]
 

Definición en la línea 111 del archivo mesh.h.

Referenciado por MESH(), y set_pintado_normales().

BOOLEAN MESH::preprocesada [private]
 

Definición en la línea 103 del archivo mesh.h.

Referenciado por imprimir(), init(), MESH(), minmax(), pintar_gl(), y pintar_povray().

BOOLEAN MESH::preprocesada_gl [private]
 

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().

BOOLEAN MESH::preservar_bordes [private]
 

Definición en la línea 100 del archivo mesh.h.

Referenciado por calcule_normales_vertice(), init(), y MESH().

long int MESH::ultima_tira [private]
 

Definición en la línea 93 del archivo mesh.h.

Referenciado por anx_tira(), init(), y MESH().

VERTICE_GL MESH::vertice_promedio [private]
 

Definición en la línea 85 del archivo mesh.h.

Referenciado por anx_vertex(), calcule_normales_vertice(), y MESH().


La documentación para esta clase fué generada a partir de los siguientes archivos:
Este archivo HTML ha sido generado automáticamente a partir del código fuente AQUYNZA. NO LO EDITE. Para mayor información contacte al autor.