mesh.h

Ir a la documentación de este archivo.

//===========================================================================
//= mesh.h                                               Septiembre de 1998 =
//=-------------------------------------------------------------------------=
//= Modulo de representacion y despliegue de geometrias 3D en mallas de     =
//= triangulos. Este modulo contiene la implementacion de la clase MESH y   =
//= esta dividido en las siguientes secciones:                              =
//=   - Inicio                                                              =
//=       Macros, descructora y constructora                                =
//=   - Servicios de construccion de TAD's internos                         =
//=       angle, calcule_normales_vertice, cree_lista_de_referencias & init =
//=   - Operaciones que precalculan datos                                   =
//=       crear_trozos_gl & crear_tiras                                     =
//=   - Operaciones de visualizacion                                        =
//=       crear_trozos_gl, crear_tiras, pintar_*_gl & compilar_lista_GL     =
//=   - Operaciones que permiten importar datos desde otras clases          =
//=       encontrar_material, calcule_normal_triangulo, anx_vertex,         =
//=       anx_triangle & anx_material                                       =
//=-------------------------------------------------------------------------=
//= Basado en el proyecto "3D Studio to OpenGL File Converter" de David     =
//= Farrell, fdavid@cyberramp.net                                           =
//= Modificado y extendido por Oscar Chavarro     oscarchavarro@hotmail.com =
//===========================================================================

#ifndef __MESH__
#define __MESH__

#include "jed_defs.h"  // Incluir antes que nada, en ese modulo se definen 
                       // aspectos importantes para la portabilidad del sistema
#include "toolkits/geom/geometria.h"
#include "arreglo.h"

#define VERTEXBLOCKSIZE 1024

class MESH;

/* Notese que TRIANGULITO, TRIANGLENODE y TROZO_GL son clases 
privadas para uso esclusivo de MESH */

class TRIANGULITO {
  private:
    GLuint p0, p1, p2;   // Indices a un arreglo de VERTICE_GL's
    GLfloat nx, ny, nz;  // Normal para este triangulo
  public:
    friend class MESH;
};

class TRIANGLENODE {               // LList used to keep track of which
  private:
    TRIANGULITO *triangle;            // triangles touch which vertices. Links
    TRIANGLENODE *sig;                // the vertices back to the triangles.
  public:
    friend class MESH;
};

class TROZO_GL {
  private:
    MATERIAL material;
    ARREGLO <TRIANGULITO> arr_triangulos;
    TRIANGULO_GL *triangulos_gl;
    char texturename[50];                  // Nombre del archivo de textura
    IMAGEN_RGB *Imagen;
    BOOLEAN inicializado;
    ARREGLO<GLuint> indices_vertices_tiras;// Tiene todos los puntos de todas las tiras
                                           // son indices al arreglo de vertices
    ARREGLO<GLuint> inicios_tiras;         // Indices en vertices_tiras con los inicios de
    ARREGLO<GLuint> longitudes_tiras;      // cada una y las longitudes

    void init(char *patron);
  public:
    TROZO_GL();
    friend class MESH;
};

class MESH : public GEOMETRIA {
  private:
    //- Esquema de representacion del MESH ---------------------------------
    ARREGLO <VERTICE_GL> arr_vertices; // El arreglo de vertices
    ARREGLO <TROZO_GL> arr_trozos_gl;  // Arreglo de secciones 
    ARREGLO <GLubyte> arr_colores;     // Colores por vertice (?)
    // Arreglo de listas de triangulos de incidencia. Usada para en calculo de 
    // normales de vertices.  La i-esima posicion es una lista de triangulos
    // que contiene todos los triangulos que inciden en el i-esimo vertice.
    ARREGLO<TRIANGLENODE *> listas_de_referencias; 

    VERTICE_GL vertice_promedio;    // Variables de estado del modelo
    GLfloat cos_threshold;          // Umbral para la particion de vertices
    double escala;                  // Escala geometrica global

    IMAGEN *imagen;                 // Textura
    char *_nombre_de_archivo;       // Archivo original si el modelo fue leido
    VECTOR _min;
    VECTOR _max;
    long int ultima_tira;           // Usado en anx_tira();
    BOOLEAN _invertir_orden;        // Usado en anx_triangle();

    //- Configuraciones de visualizacion -----------------------------------
    BOOLEAN con_lista_gl;           // Activacion de optimizacion OpenGL
    BOOLEAN calcular_normales;      // ?
    BOOLEAN centrar_modelo;         // Se resta el vertice_promedio...
    BOOLEAN preservar_bordes;       // ?
    BOOLEAN normales_de_triangulo;  // ?
    BOOLEAN modo_tiras_de_triangulos; // Utiliza stripe para generarse!
    BOOLEAN preprocesada;           // Flags de configuracion
    BOOLEAN con_minmax;  
  #ifdef GL_ENABLED
    int id_lista_opengl;  // Para acelerar OpenGL, solo aplica si con_lista_gl
    BOOLEAN preprocesada_gl;  // ?
  #endif

    //- Elementos de depuracion visual -------------------------------------
    BOOLEAN pintar_normales; // Si es TRUE representa con lineas las normales
    BOOLEAN *Arr_control;    // Permite especificar los trozos_gl a pintar
    BOOLEAN pintar_debug_vertices; // Representacion resaltada de un vertice
    long int index_debug_vertice;  // Vertice activo para ser resaltado
    BOOLEAN pintar_debug_triangulos;
    long int index_debug_triangulo;
    BOOLEAN material_global; // Cambia el uso del color
    BOOLEAN mostrar_tiras;   // Cambia el uso del color

    //--- Operaciones que precalculan datos ---
    void crear_trozos_gl(void);
    void crear_tiras(void);

    //--- Operaciones constructoras ---
    GLfloat angulo_de_vertice(TRIANGULITO *, GLuint);
    void calcule_normales_vertice(void);
    void cree_lista_de_referencias(void);
    void anexar_trozo_obj(char *linea);

    //--- Operaciones que permiten importar datos desde otras clases ---
    int encontrar_material(char *);
    BOOLEAN calcule_normal_triangulo(TRIANGULITO *Triangulo);

    //- Operaciones de visualizacion --------
    void pintar_triangulos_gl(CALIDAD_VISUAL *Calidad);
    void pintar_triangulos_tira_gl(CALIDAD_VISUAL *Calidad);
    void pintar_triangulosv_gl(CALIDAD_VISUAL *Calidad);
    void pintar_triangulosv_tira_gl(CALIDAD_VISUAL *Calidad);
    void compilar_lista_gl(int lista_gl, CALIDAD_VISUAL *Calidad);
    void nucleo_pintar_gl(CALIDAD_VISUAL *Calidad);
    void pintar_debug_vertice(long int i);    // Depuracion visual
    void pintar_debug_triangulo(long int i);  // Depuracion visual

  public:
    //- Interfaz generica de geometrias AQUYNZA ----------------------------
    MESH(int threshold, BOOLEAN strips, BOOLEAN center_model, double scale);
    virtual ~MESH();

    void anexar_textura(IMAGEN *img);
    int clasificar_punto(VECTOR p);
    void minmax(VECTOR *min, VECTOR *max);
#ifdef GL_ENABLED
    void
    pintar_gl(CALIDAD_VISUAL *Calidad, MATERIAL* Material, CAMARA *Camara);
#endif
    void pintar_povray(FILE *fd);
    void pintar_aqz(FILE *fd);

    //- Interfaz particular de la clase MESH -------------------------------
    void init(void);
    void promediar_normales_vertice(void);
    void anx_vertex(VERTICE_GL);           // Constructora
    void anx_indice_tira(long int i);      // Constructora
    void anx_tira(void);                   // Constructora
    void anx_color(GLubyte r, GLubyte g, GLubyte b);
    void anx_triangle(TRIANGULO_GL, char *nombre_material); // Constructora
    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);
    BOOLEAN importar_obj(char *archivo, double *Escala_optima);
    BOOLEAN exportar_obj(FILE *fd, int i);

    //- Particular a MESH: Ayudas a la depuracion visual --------------------
    void set_pintado_normales(BOOLEAN c);   // Representacion de normales 
    long int num_vertices(void);            // Indica el numero de vertices
    void set_debug_vertices(BOOLEAN c);     // Representacion de vertices
    void set_debug_vertices_index(long int i); // Representacion de vertices
    long int num_triangulos(void);          // Indica el numero de triangulos
    void set_debug_triangulos(BOOLEAN c);
    void set_debug_triangulos_index(long int i);
    int  num_grupos(void);                  // Indica el numero de trozos_gl
    void controlar(BOOLEAN *arr_control);   // Control de trozos_gl a pintar
    void imprimir(BOOLEAN full_report = TRUE); // Para entender la estructura 
    void set_material_global(BOOLEAN m);    // Cambia el uso del color
    void set_debug_tiras(BOOLEAN t);        // Cambia el uso del color
};

#endif  // __MESH__

//===========================================================================
//= EOF                                                                     =
//===========================================================================

---

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.