mesh.C

Ir a la documentación de este archivo.

//===========================================================================
//= mesh.cc                 Septiembre de 1998, revisado en octubre de 1999 =
//=-------------------------------------------------------------------------=
//= 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                         =
//=       angulo_de_vertice, calcule_normales_vertice,                      =
//=       cree_lista_de_referencias & init                                  =
//=   - Operaciones que precalculan datos                                   =
//=       crear_trozos_gl & crear_tiras                                     =
//=   - Operaciones que permiten importar datos desde otras clases          =
//=       encontrar_material, calcule_normal_triangulo, anx_vertex,         =
//=       anx_triangle & anx_material                                       =
//= Notese que las siguientes operaciones han sido aisladas en el modulo    =
//= `mesh_gl`:                                                              =
//=   - Operaciones de visualizacion                                        =
//=       crear_trozos_gl, crear_tiras, pintar_*_gl, nucleo_pintar_gl y     =
//=       compilar_lista_gl                                                 =
//=-------------------------------------------------------------------------=
//= Comentarios del autor original de quien se basa este codigo:            =
//= The data structures used in this module are probably hard for anyone    =
//= else to understand, so let me explain my code. There are three main     =
//= data structures in use: arr_vertices, poligonos_arr, and                =
//= listas_de_referencias.                                                =
//=                                                                         =
//= arr_vertices is the list of vertices and normals that polygons index in =
//=  to. OpenGL accepts this array as a vertex array. The normals stored    =
//=  in this array are normals *for each vertex*, not the polygon normals.  =
//=                                                                         =
//= poligonos_arr is an array of materials. A material is a group of        =
//=  attributes such as diffuse color, shininess, a texture map, etc. It    =
//=  contains an array of triangles stored as 3-tuples of integers. These   =
//=  are indexes into the arr_vertices array. An example:                   =
//=       arr_vertices[poligonos_arr[2].arr_triangulos[3].p0]               =
//=       arr_vertices[poligonos_arr[2].arr_triangulos[3].p1]               =
//=       arr_vertices[poligonos_arr[2].arr_triangulos[3].p2]               =
//=  are the three points of the fourth triangle of the third material. Of  =
//=  course, *each* of these points (p0, p1, and p2) have three GLfloats    =
//=  associated with them as X,Y,Z data.                                    =
//=                                                                         =
//= listas_de_referencias is an array the same size as arr_vertices.      =
//= Each of it's positions is a linked list of pointers into the            =
//= poligonos_arr[].arr_triangulos of  every triangle that touches that     =
//= vertex. Another example:                                                =
//=       for(ptr = listas_de_referencias[5]; ptr; ptr=ptr->sig)          =
//=           printf("%d %d %d\n",                                          =
//=               ptr->triangle->p0, ptr->triangle->p1, ptr->triangle->p2); =
//=  This will traverse a linked list, producing the integer indexes of the =
//=  three points of all the triangles that touch vertex 5. This is the     =
//=  same vertex 5 as arr_vertices[5]. This is used for building the        =
//=  normals for each vertex where we may have to produce two vertexes with =
//=  the same X,Y,Z but different normals due to sharp edges.               =
//=-------------------------------------------------------------------------=
//= Basado en el proyecto "3D Studio to OpenGL File Converter" de David     =
//= Farrell, fdavid@cyberramp.net                                           =
//= Modificado y extendido por Oscar Chavarro      oscarchavarro@hotmail.co =
//===========================================================================

#include <math.h>
#include <stdio.h>
#include <stdlib.h>
#include <string.h>

#include "toolkits/geom/mesh.h"
#include "matriz4.h"
#include "lista.cc"
#include "arreglo.cc"

#ifdef GL_VERSION_1_1  // OJO: Toca revisar si esta vaina funciona bien!
    #define GL_COMPLETO
#endif

#if PLATAFORMA == SGI
    #undef GL_COMPLETO  // OJO: Esto es un machete!
#endif

//#define DEBUG_MESH

//===========================================================================
//= Macros locales                                                          =
//===========================================================================

#define VERIFICAR(m) \
    if ( !m ) { \
        fprintf(stderr, "<MESH> ERROR: Falla de memoria dinamica.\n"); \
        fflush(stderr); \
        exit(-1); \
    }

#define VERIFICAR1(m) \
    if ( !m ) { \
        fprintf(stderr, "<MESH> ERROR: Falla de memoria dinamica (STRIP).\n");\
        fflush(stderr); \
        exit(-1); \
    }

/*  Returns the cosine of the angle between two normals.
 * Since the normals are already normalized, we don't need to
 * divide by the product of their magnitudes. We only need
 * to return the dot product since the denominator will always
 * be 1. */
#define cos_angle(a, b) \
    ((a)->nx * (b)->nx) + ((a)->ny * (b)->ny) + ((a)->nz * (b)->nz)

#define COMPARAR_MM()                           \
        if ( p.x < _min.x ) _min.x = p.x;       \
        if ( p.y < _min.y ) _min.y = p.y;       \
        if ( p.z < _min.z ) _min.z = p.z;       \
        if ( p.x > _max.x ) _max.x = p.x;       \
        if ( p.y > _max.y ) _max.y = p.y;       \
        if ( p.z > _max.z ) _max.z = p.z;

//===========================================================================
//= CLASE MESH                                                              =
//===========================================================================

MESH::MESH(int threshold, BOOLEAN strips, BOOLEAN center_model, double scale)
    : arr_vertices(VERTEXBLOCKSIZE), arr_trozos_gl(1), 
      arr_colores(VERTEXBLOCKSIZE), listas_de_referencias(VERTEXBLOCKSIZE) 
{
    //- Empiece como un objeto vacio ---------------------------------------
    vertice_promedio.x = vertice_promedio.y = vertice_promedio.z = 0;

    //- Flags por defecto --------------------------------------------------
    material_global = FALSE;
    calcular_normales = TRUE;
    preprocesada = FALSE;
#ifdef GL_ENABLED
    preprocesada_gl = FALSE;
#endif
    modo_tiras_de_triangulos = FALSE;
    centrar_modelo = FALSE;
    preservar_bordes = FALSE;
    Arr_control = NULL;
    pintar_normales = FALSE;
    pintar_debug_vertices = FALSE;
    pintar_debug_triangulos = FALSE;
    index_debug_vertice = 0;
    index_debug_triangulo = 0;
    mostrar_tiras = FALSE;
    con_minmax = FALSE;
    ultima_tira = 0;
    _invertir_orden = FALSE;

  #if PLATAFORMA == i386_WIN32_VC  // OJO: Esto es un machete, debido a falta de 
    con_lista_gl = FALSE;     // informacion a la hora de integrar OpenGL
  #else                       // con el SDK de Windows.
    con_lista_gl = FALSE;  // OJO!
  #endif

    normales_de_triangulo = FALSE;

    //- Flags configurables por el usuario mediante los atributos ----------
    _nombre_de_archivo = NULL;
    if ( strips ) modo_tiras_de_triangulos = TRUE;
    if ( center_model ) centrar_modelo = TRUE;
    if ( threshold ) {
        cos_threshold = (GLfloat)cos(threshold*PI/180.0);
        preservar_bordes = TRUE;
        if ( threshold > 180 ) normales_de_triangulo = TRUE;
      }
      else {
        preservar_bordes = FALSE;
        normales_de_triangulo = TRUE;
    }
    escala = scale;

    imagen = NULL;
}

MESH::~MESH(void)
{
    int i;
    //TRIANGLENODE *LList;
    //TRIANGLENODE *TempPtr;

    arr_vertices.elim();
    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        arr_trozos_gl[i].arr_triangulos.elim();
        delete arr_trozos_gl[i].triangulos_gl;
    }
    /*
    for ( i = 0; i < arr_vertices.tam(); i++ ) {
        LList = listas_de_referencias[i];
        while (LList) {
            TempPtr = LList;
            LList = LList->sig;
            delete TempPtr;
        }
    }
    */
    if ( _nombre_de_archivo ) {
        delete _nombre_de_archivo;
    }
    listas_de_referencias.elim();
    arr_trozos_gl.elim();
}

//= SERVICIOS DE CONSTRUCCION DE TAD'S INTERNOS =============================

void
MESH::get_vertices(VERTICE_GL **V, long int *n)
{
    (*V) = arr_vertices.data();
    (*n) = arr_vertices.tam();

    //preprocesada = FALSE;     // OJO: El usuario debera dar init!
    //preprocesada_gl = FALSE;

    if ( con_lista_gl ) {
        //glDeleteLists(id_lista_opengl, 1); // Y esto no funciona a veces!
        // OJO: Esto es machete!
        con_lista_gl = FALSE;
    }
}

void
MESH::set_invertir_orden(BOOLEAN o)
{
    _invertir_orden = o;
}

void
MESH::set_nombre_de_archivo(char *c)
{
    _nombre_de_archivo = c;
}

void
MESH::set_escala(double e)
{
    escala = e;
}

inline GLfloat
MESH::angulo_de_vertice(TRIANGULITO *triangle, GLuint vertex)
{
    double a,b,c;

    if ( triangle->p0 == vertex ) {
        a = DISTANCIA_VGL(&arr_vertices[triangle->p0],
                          &arr_vertices[triangle->p1]);
        b = DISTANCIA_VGL(&arr_vertices[triangle->p0],
                          &arr_vertices[triangle->p2]);
        c = DISTANCIA_VGL(&arr_vertices[triangle->p1],
                          &arr_vertices[triangle->p2]);
      }
      else if ( triangle->p1 == vertex ) {
        a = DISTANCIA_VGL(&arr_vertices[triangle->p1],
                          &arr_vertices[triangle->p0]);
        b = DISTANCIA_VGL(&arr_vertices[triangle->p1],
                          &arr_vertices[triangle->p2]);
        c = DISTANCIA_VGL(&arr_vertices[triangle->p2],
                          &arr_vertices[triangle->p0]);
      }
      else if (triangle->p2 == vertex) {
        a = DISTANCIA_VGL(&arr_vertices[triangle->p2],
                          &arr_vertices[triangle->p0]);
        b = DISTANCIA_VGL(&arr_vertices[triangle->p2],
                          &arr_vertices[triangle->p1]);
        c = DISTANCIA_VGL(&arr_vertices[triangle->p0],
                          &arr_vertices[triangle->p1]);
      }
      else {
        // ERROR: Algo alda mal!
        fprintf(stderr, "!");
        return 60;
      }
    ;
    
    return (GLfloat)acos( (c*c - a*a - b*b) / (2*a*b) );
}

void
MESH::calcule_normales_vertice(void)
{
    int orig_arr_vertices_tam;
    int i;
    long int error_vertice_suelto = 0;

    orig_arr_vertices_tam = arr_vertices.tam();

    //- 1a. CALCULA TODAS LAS NORMALES SI HAY UN SOLO TRIANGULO POR VERTICE -
    int j;
    TRIANGULITO *pptr;

    if ( normales_de_triangulo ) {
        for ( j = 0; j < arr_trozos_gl.tam(); j++ ) {
            for ( i = 0; i < arr_trozos_gl[j].arr_triangulos.tam(); i++ ) {
                pptr=&(arr_trozos_gl[j].arr_triangulos[i]);
                arr_vertices[pptr->p0].nx = pptr->nx;
                arr_vertices[pptr->p0].ny = pptr->ny;
                arr_vertices[pptr->p0].nz = pptr->nz;
                arr_vertices[pptr->p1].nx = pptr->nx;
                arr_vertices[pptr->p1].ny = pptr->ny;
                arr_vertices[pptr->p1].nz = pptr->nz;
                arr_vertices[pptr->p2].nx = pptr->nx;
                arr_vertices[pptr->p2].ny = pptr->ny;
                arr_vertices[pptr->p2].nz = pptr->nz;
            }
        }
    }

    //- 1b. CALCULE LAS NORMALES PARA TODOS LOS VERTICES --------------------
    BOOLEAN ya_hice_vertice_nuevo;
    TRIANGLENODE *ptr;
    TRIANGLENODE *qtr;
    GLfloat TotalAngles;
    GLfloat VertexAngle;
    GLfloat magnitude;

    for ( i = 0; !normales_de_triangulo && i < arr_vertices.tam(); i++ ) {
        //- Preparese para el calculo de la normal --------------------------
        // OJO: La normal es <0, 0, 0> porque se va a ir acumulando
        arr_vertices[i].nx = arr_vertices[i].ny = arr_vertices[i].nz = 0;
        ya_hice_vertice_nuevo = FALSE;
        TotalAngles = 0;

        //- Recorra la lista de triangulos que tocan este vertice... --------
        ptr = listas_de_referencias[i]; // O sea ptr = cab;
        while ( ptr ) {
            if ( preservar_bordes && 
                 cos_angle(listas_de_referencias[i]->triangle,
                           ptr->triangle) <= cos_threshold) {
                /* Put this triangle at another vertex */
                if ( !ya_hice_vertice_nuevo ) {
                    /* Make a copy of this vertex at the end of the vertex 
                       list */
                    ya_hice_vertice_nuevo = TRUE;
                    // Notese que la copia de este vertice no contribuye al
                    // calculo del centro...
                    anx_vertex(arr_vertices[i]);
                    vertice_promedio.x -= arr_vertices[i].x;
                    vertice_promedio.y -= arr_vertices[i].y;
                    vertice_promedio.z -= arr_vertices[i].z;
                }
                /* Attach this surface to the last vertex's list of adjacent 
                 * triangles must be in this order or our ->sig's won't link
                 * correctly  */
                qtr = ptr;
                ptr = ptr->sig;
                qtr->sig = listas_de_referencias[arr_vertices.tam()-1];
                listas_de_referencias[arr_vertices.tam()-1] = qtr;
                /* Change the vertex indices so that we point to the new vertex
                 * instead of the one we were originally pointing to. */
                if ( qtr->triangle->p0 == (GLuint)i ) {
                    qtr->triangle->p0 = arr_vertices.tam()-1;
                }
                if ( qtr->triangle->p1 == (GLuint)i ) {
                    qtr->triangle->p1 = arr_vertices.tam()-1;
                }
                if ( qtr->triangle->p2 == (GLuint)i ) {
                    qtr->triangle->p2 = arr_vertices.tam()-1;
                }
              } 
              else {
                /* Since it's less then the threshold angle, calculate the 
                 * angle that this polygon shares with the vertex  */
                VertexAngle = angulo_de_vertice(ptr->triangle, i);
                arr_vertices[i].nx += ptr->triangle->nx * VertexAngle;
                arr_vertices[i].ny += ptr->triangle->ny * VertexAngle;
                arr_vertices[i].nz += ptr->triangle->nz * VertexAngle;
                TotalAngles += VertexAngle;
                ptr = ptr->sig;
            }  // if-else
        } // while

        //- Calcule la normal (unitaria) para este vertice ------------------
        if ( IGUAL(0.0, TotalAngles) ) {
            // Este es un vertice suelto (no participa en ningun poligono!)
            error_vertice_suelto++;
            arr_vertices[i].nz = 1;
            continue;
        }
        arr_vertices[i].nx /= TotalAngles;
        arr_vertices[i].ny /= TotalAngles;
        arr_vertices[i].nz /= TotalAngles;
        // Normalizacion del vector
        magnitude = (GLfloat)sqrt(
                               ((arr_vertices[i].nx * arr_vertices[i].nx) +
                               (arr_vertices[i].ny * arr_vertices[i].ny) +
                               (arr_vertices[i].nz * arr_vertices[i].nz))   );
        arr_vertices[i].nx /= magnitude;
        arr_vertices[i].ny /= magnitude;
        arr_vertices[i].nz /= magnitude;
    } // for ( i = 0; i < arr_vertices.tam(); i++ )...

    //- 2. OJO: Esto ayuda a que el objeto sea mas manejable! ---------------
    if ( centrar_modelo ) {
        vertice_promedio.x /= orig_arr_vertices_tam;
        vertice_promedio.y /= orig_arr_vertices_tam;
        vertice_promedio.z /= orig_arr_vertices_tam;
        
        for ( i = 0; i < arr_vertices.tam(); i++ ) {
            arr_vertices[i].x -= vertice_promedio.x;
            arr_vertices[i].y -= vertice_promedio.y;
            arr_vertices[i].z -= vertice_promedio.z;

            // Invertir la normal
            //arr_vertices[i].nx *= -1;
            //arr_vertices[i].ny *= -1;
            //arr_vertices[i].nz *= -1;
        }
    }

    if ( error_vertice_suelto ) {
        fprintf(stderr, "<MESH> - Warning: %ld vertices sueltos, de los "
                "%ld vertices del modelo\n", 
                error_vertice_suelto, arr_vertices.tam());
        fflush(stderr);
    }
}

void
MESH::cree_lista_de_referencias(void)
{
    TRIANGULITO *Triangulo;
    TRIANGLENODE *qtr;
    int i, j;

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {
            /* For each triangle, insert a pointer to the triangle */
            /* into a linked list hanging off of each of the three */
            /* vertices it touches.                                */
            Triangulo = &arr_trozos_gl[i].arr_triangulos[j];

            /* Point One */
            qtr = new TRIANGLENODE;
            qtr->triangle = Triangulo;
            // Inserta el nodo en la cabeza de la lista del vertice T->p0
            qtr->sig = listas_de_referencias[Triangulo->p0];
            listas_de_referencias[Triangulo->p0] = qtr;
            
            /* Point Two */
            qtr = new TRIANGLENODE;
            qtr->triangle = Triangulo;
            // Inserta el nodo en la cabeza de la lista del vertice T->p1
            qtr->sig = listas_de_referencias[Triangulo->p1];
            listas_de_referencias[Triangulo->p1] = qtr;
            
            /* Point Three */
            qtr = new TRIANGLENODE;
            qtr->triangle = Triangulo;
            // Inserta el nodo en la cabeza de la lista del vertice T->p2
            qtr->sig = listas_de_referencias[Triangulo->p2];
            listas_de_referencias[Triangulo->p2] = qtr;
        }
    }
}

void
MESH::init(void)
{
  #ifdef DEBUG_MESH
    int vertices_originales = arr_vertices.tam();
  #endif
    int i, acum_triangulos = 0;

  #ifdef DEBUG_MESH
    printf("<MESH>: Recibo un modelo con %ld vertices\n", arr_vertices.tam());
    printf("<MESH>: precalculando normales para los vertices... ");
    fflush(stdout);
  #endif

    if ( calcular_normales ) {
        cree_lista_de_referencias();
        calcule_normales_vertice();
    }


  #ifdef DEBUG_MESH
    printf("Ok!\n"); fflush(stdout);
  #endif

    if ( modo_tiras_de_triangulos && ultima_tira == 0 ) crear_tiras();
    else if ( ultima_tira == 0 ) crear_trozos_gl();

  #ifdef DEBUG_MESH
    if ( preservar_bordes ) {
        printf("<MESH>: Se han generado %ld vertices nuevos con normales para "
               "preservar\n        la apariencia de los bordes en la geometria"
               " del modelo.\n", arr_vertices.tam() - vertices_originales);
    }
  #endif

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        acum_triangulos += arr_trozos_gl[i].arr_triangulos.tam();
    }
  #ifdef DEBUG_MESH
    printf("<MESH>: El modelo quedo con %ld vertices y %d triangulos\n",
        arr_vertices.tam(), acum_triangulos);
  #endif

    preprocesada = TRUE;
}

void
MESH::promediar_normales_vertice(void)
{
    long i, j;
    ARREGLO <BOOLEAN> arr_banderas(arr_vertices.tam());

    //- Desmarcar todos los vertices ----------------------------------------
    for ( i = 0; i < arr_vertices.tam(); i++ ) {
        arr_banderas.anx(FALSE);
    }

    //-----------------------------------------------------------------------
    for ( i = 0; i < arr_vertices.tam(); i++ ) {
        // El vertice ya habia sido procesado, me lo salto
        if ( arr_banderas[i] ) continue;
        arr_banderas[i] = TRUE;
        // Armo el grupo de todos los vertices cercanos
        ARREGLO <int> arr_vecinos(100);
        arr_vecinos.anx(i);
        for ( j = i+1; j < arr_vertices.tam(); j++ ) {
            if ( !arr_banderas[j] &&
                DISTANCIA_VGL(&arr_vertices[i], &arr_vertices[j]) < 30*EPSILON 
               ) {
                arr_banderas[j] = TRUE;
                arr_vecinos.anx(j);
            }
        }
        // Promedio la normal y la asigno en todos los vecinos
        VECTOR n(0, 0, 0);

        for ( j = 0; j < arr_vecinos.tam(); j++ ) {
            n.x += arr_vertices[arr_vecinos[j]].nx;
            n.y += arr_vertices[arr_vecinos[j]].ny;
            n.z += arr_vertices[arr_vecinos[j]].nz;
        }
        n.normalizar();
        for ( j = 0; j < arr_vecinos.tam(); j++ ) {
            arr_vertices[arr_vecinos[j]].nx = (float)n.x;
            arr_vertices[arr_vecinos[j]].ny = (float)n.y;
            arr_vertices[arr_vecinos[j]].nz = (float)n.z;
        }
    }
}

//= OPERACIONES QUE PRECALCULAN DATOS =======================================

void
MESH::crear_trozos_gl(void)
{
    int i, j;

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        arr_trozos_gl[i].triangulos_gl = 
                new TRIANGULO_GL[arr_trozos_gl[i].arr_triangulos.tam()+1];
        for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {
            arr_trozos_gl[i].triangulos_gl[j].p0 =
                arr_trozos_gl[i].arr_triangulos[j].p0;
            arr_trozos_gl[i].triangulos_gl[j].p1 =
                arr_trozos_gl[i].arr_triangulos[j].p1;
            arr_trozos_gl[i].triangulos_gl[j].p2 =
                arr_trozos_gl[i].arr_triangulos[j].p2;
        }
    }

#ifdef NO_FUNCIONA
    //- Dele la vuelta a los triangulos para que queden bien orientados -----
    double x1, y1, z1, nx1, ny1, nz1;
    double x2, y2, z2, nx2, ny2, nz2;
    double x3, y3, z3, nx3, ny3, nz3;
    VECTOR l1, l2, normal, anti_normal;
    int a, b, c;
    GLuint tmp;

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {                             
        for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {       
           a = arr_trozos_gl[i].triangulos_gl[j].p0;
           b = arr_trozos_gl[i].triangulos_gl[j].p1;
           c = arr_trozos_gl[i].triangulos_gl[j].p2;
           nx1 = arr_vertices[a].nx;
           ny1 = arr_vertices[a].ny;
           nz1 = arr_vertices[a].nz;
           x1 = arr_vertices[a].x;
           y1 = arr_vertices[a].y;
           z1 = arr_vertices[a].z;
           nx2 = arr_vertices[b].nx;
           ny2 = arr_vertices[b].ny;
           nz2 = arr_vertices[b].nz;
           x2 = arr_vertices[b].x;
           y2 = arr_vertices[b].y;
           z2 = arr_vertices[b].z;
           nx3 = arr_vertices[c].nx;
           ny3 = arr_vertices[c].ny;
           nz3 = arr_vertices[c].nz;
           x3 = arr_vertices[c].x;
           y3 = arr_vertices[c].y;
           z3 = arr_vertices[c].z;
           normal.x = nx3;
           normal.y = ny3;
           normal.z = nz3;
           l1.x = x1 - x3;    l1.y = y1 - y3;    l1.z = z1 - z3;
           l2.x = x2 - x3;    l2.y = y2 - y3;    l2.z = z2 - z3;
           anti_normal = l1.producto_cruz(l2);

           if ( anti_normal.producto_punto(normal) < 0 ) {
               printf("~"); fflush(stdout);
               tmp = arr_trozos_gl[i].triangulos_gl[j].p1;
               arr_trozos_gl[i].triangulos_gl[j].p1 = 
                   arr_trozos_gl[i].triangulos_gl[j].p0;
               arr_trozos_gl[i].triangulos_gl[j].p0 = tmp;
           }
        }                                                               
    }                             
    printf("Voy...\n");
    fflush(stdout);
#endif // NO_FUNCIONA

}

void
MESH::crear_tiras(void)
{
    //- Variables -----------------------------------------------------------
    int i,j;
    FILE *fd_in, *fd_out;
    char line[256];
    char filename[256];
    char command[256];
    
    printf("<MESH> Generando tiras de triangulos para %ld trozos: [ ",
           arr_trozos_gl.tam()); 
    fflush(stdout);

    //- Ciclo: Se repite el proceso para cada uno de los trozos_gl ----------
    int longitudes_actual;
    int inicios_actual;
    BOOLEAN primera_tira;

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        longitudes_actual = 0;
        inicios_actual = 0;
        primera_tira = TRUE;
        // Generacion de un archivo wavefront (obj) para que lo lea stripe
        sprintf(filename, "temp%d.obj", i);
        fd_out = fopen(filename, "w");
        exportar_obj(fd_out, i);
        fclose(fd_out);

        // Ejecucion de la utilidada externa STRIPE
      #if PLATAFORMA == i386_WIN32_VC
        sprintf(command, "stripe -p %s > shudup", filename); system(command);
        sprintf(command, "erase shudup");                    system(command);
        sprintf(command, "erase %s", filename);              system(command);
      #endif
      #if PLATAFORMA != i386_WIN32_VC
        sprintf(command, "stripe %s > /dev/null", filename); system(command);
        sprintf(command, "rm %s", filename);                 system(command);
      #endif

        // Recapture los resultados
        strcat(filename, "f");
        fd_in = fopen(filename,"r");

        // Count the number of strip points and initialize arr_trozos_gl
        while ( fscanf(fd_in, "%s", line) != EOF ) {
            switch( line[0] ) {
              case '#': // # is a comment, v is a vertex, we ignore both
              case 'v':
                while (fgetc(fd_in) != '\n');
                break;
              case 't': // t is the start of a new triangle strip
                if ( primera_tira ) {
                    primera_tira = FALSE;
                  }
                  else {
                    arr_trozos_gl[i].inicios_tiras.anx(inicios_actual);
                    arr_trozos_gl[i].longitudes_tiras.anx(longitudes_actual);
                    longitudes_actual = 0;
                }
                break;
              case 'q': // q is another entry in the current strip
              case '%': // % is a STRIPE type
                break;
              default: //Anything else is a point in the current triangle strip
                arr_trozos_gl[i].indices_vertices_tiras.anx((GLuint)(atoi(line)-1));
                inicios_actual++;
                longitudes_actual++;
                break;
            }
        }
        arr_trozos_gl[i].inicios_tiras.anx(inicios_actual);
        arr_trozos_gl[i].longitudes_tiras.anx(longitudes_actual);
        fclose(fd_in);

        //------------------------------------------------------------------
      #if PLATAFORMA == i386_WIN32_VC
        sprintf(command, "erase %s", filename);        system(command);
      #endif
      #if PLATAFORMA != i386_WIN32_VC
        sprintf(command, "rm %s", filename);           system(command);
      #endif

        for ( j = 0; j < arr_trozos_gl[i].indices_vertices_tiras.tam(); j++ ) {
            if ( 
                 /* OJO: Notese que la 1ra condicion siempre es TRUE */
                 /* arr_trozos_gl[i].indices_vertices_tiras[j] < (GLuint)0 || */
                 arr_trozos_gl[i].indices_vertices_tiras[j] > (GLuint)(arr_vertices.tam()-1)
                ) {
                exit(-1);
            }
        }
        printf("."); fflush(stdout);
    }
    printf(" ] Ok.\n");  fflush(stdout);
    con_minmax = FALSE;
}

//= OPERACIONES QUE PERMITEN IMPORTAR DATOS DESDE OTRAS CLASES ==============

int
MESH::encontrar_material(char *name)
/* Finds the index of the material in question */
{
    int n;

    for ( n = 0; n < arr_trozos_gl.tam(); n++ ) {
        if ( strcmp(name, arr_trozos_gl[n].material.nombre()) == 0 ) {
            return n;
        }
    }

    if ( n >= arr_trozos_gl.tam() ) {
        if ( arr_trozos_gl.tam() ) {
            fprintf(stderr, "!");
            fflush(stderr);
            return 0;
        }
        fprintf(stderr, "<MESH> - ERROR: No se encuentra el material \"%s\"\n",
            name);
        fprintf(stderr, "<MESH> No hay materiales, abortando"); fflush(stderr);
        exit(-1); 
    }
    return 0;
}

BOOLEAN
MESH::calcule_normal_triangulo(TRIANGULITO *Triangulo)
{
    VECTOR normal, p0, p1, p2, a, b;

    p0.x = arr_vertices[Triangulo->p0].x;
    p0.y = arr_vertices[Triangulo->p0].y;
    p0.z = arr_vertices[Triangulo->p0].z;
    p1.x = arr_vertices[Triangulo->p1].x;
    p1.y = arr_vertices[Triangulo->p1].y;
    p1.z = arr_vertices[Triangulo->p1].z;
    p2.x = arr_vertices[Triangulo->p2].x;
    p2.y = arr_vertices[Triangulo->p2].y;
    p2.z = arr_vertices[Triangulo->p2].z;

    a = p1 - p0; //a.normalizar();
    b = p2 - p0; //b.normalizar();
    normal = a.producto_cruz(b);

    if ( normal.norma() == 0 ) {
        // OJO: Triangulo invalido, normal indeterminada!
        fprintf(stderr, "-"); fflush(stdout);
        return FALSE;
    }

    normal.normalizar();

    Triangulo->nx = (float)normal.x;
    Triangulo->ny = (float)normal.y;
    Triangulo->nz = (float)normal.z;

    return TRUE;
}

void
MESH::anx_indice_tira(long int i)
{
    arr_trozos_gl[0].indices_vertices_tiras.anx(i);
}

void
MESH::anx_tira(void)
{
    long int a = arr_trozos_gl[0].indices_vertices_tiras.tam();
    arr_trozos_gl[0].inicios_tiras.anx(ultima_tira);
    arr_trozos_gl[0].longitudes_tiras.anx(a-ultima_tira);
    modo_tiras_de_triangulos = TRUE;
    ultima_tira = a;
}

void
MESH::anx_vertex(VERTICE_GL v)
/* Adds a vertex to the vertex list */
{
    //-----------------------------------------------------------------------
    arr_vertices.anx(v);

    //-----------------------------------------------------------------------
    vertice_promedio.x += v.x;
    vertice_promedio.y += v.y;
    vertice_promedio.z += v.z;

    //-----------------------------------------------------------------------
    /*  Add a slot into the array we're building to keep track of which     
     * triangles are part of which vertices, which will be used to build 
     * vertex normals.  */
    listas_de_referencias.anx(NULL);
}

void
MESH::anx_color(GLubyte r, GLubyte g, GLubyte b)
{
    arr_colores.anx(r);
    arr_colores.anx(g);
    arr_colores.anx(b);
}

void
MESH::anx_triangle(TRIANGULO_GL tri, char *nombre_material)
{
    // Verifique que es un triangulo valido
    unsigned long int ta;

    ta = arr_vertices.tam();
    if ( tri.p0 >= ta || tri.p1 >= ta || tri.p2 >= ta ) return;
    // Mmm... si son unsigned int's tiene sentido comparar contra < 0?
    //if ( tri.p0 < 0 || tri.p1 < 0 || tri.p2 < 0 ) return;

    // Determine el grupo en base al material del triangulo
    int MatNum;
    TROZO_GL *list;

    MatNum = encontrar_material(nombre_material);
    list = &arr_trozos_gl[MatNum];

    // Si el orden es inverso... 
    TRIANGULITO t;

    if ( _invertir_orden ) {
        t.p0 = tri.p0;
        t.p1 = tri.p2;
        t.p2 = tri.p1;
      }
      else {
        t.p0 = tri.p0;
        t.p1 = tri.p1;
        t.p2 = tri.p2;
    }

    // Si el triangulo no es colineal, insertelo
    if ( !calcule_normal_triangulo(&t) ) return;
    list->arr_triangulos.anx(t);
}

void
MESH::anx_material(COLOR ambient, COLOR diffuse, COLOR specular,
             char *name, char *texname, int caras_dobles)
/* Add a material to the model */
{
    //-----------------------------------------------------------------------
    COLOR e(0, 0, 0);
    TROZO_GL t;

    t.material.set_nombre(name);
    strcpy(t.texturename, texname);
    t.material.set_ambiente(ambient);
    t.material.set_difusa(diffuse);
    t.material.set_especular(specular);
    t.material.set_emision(e);
    t.material.set_transparencia(1);
    if ( caras_dobles ) {
       t.material.set_doble_cara(TRUE);
    }

    //-----------------------------------------------------------------------
    arr_trozos_gl.anx(t);
}

//= OPERACIONES STANDARD DE GEOMETRIA AQUYNZA ===============================

void
MESH::anexar_textura(IMAGEN *img)
{ 
    if ( imagen ) delete imagen;
    imagen = img;
}

int
MESH::clasificar_punto(VECTOR /*p*/)
{
    return 0;
}

void
MESH::minmax(VECTOR *min, VECTOR *max)
{
    int i, j, k;
    VECTOR p;

    if ( !preprocesada ) {
        init();
    }    

    if ( !con_minmax ) {
        _min.x = INFINITO;
        _min.y = INFINITO;
        _min.z = INFINITO;
        _max.x = -INFINITO;
        _max.y = -INFINITO;
        _max.z = -INFINITO;
    
        for ( i = 0; !modo_tiras_de_triangulos && i < arr_trozos_gl.tam(); i++ ) {
            for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {
                p.x = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].x;
                p.y = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].y;
                p.z = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].z;
                COMPARAR_MM();
                p.x = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].x;
                p.y = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].y;
                p.z = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].z;
                COMPARAR_MM();
                p.x = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].x;
                p.y = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].y;
                p.z = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].z;
                COMPARAR_MM();
            }
        }
    
        for ( i = 0; modo_tiras_de_triangulos && i < arr_trozos_gl.tam(); i++ ) {
            for ( j = 0; j < arr_trozos_gl[i].indices_vertices_tiras.tam(); j++ ) {
                k = arr_trozos_gl[i].indices_vertices_tiras[j];
                p.x = arr_vertices[k].x;
                p.y = arr_vertices[k].y;
                p.z = arr_vertices[k].z;
                COMPARAR_MM();
                p.x = arr_vertices[k].x;
                p.y = arr_vertices[k].y;
                p.z = arr_vertices[k].z;
                COMPARAR_MM();
                p.x = arr_vertices[k].x;
                p.y = arr_vertices[k].y;
                p.z = arr_vertices[k].z;
                COMPARAR_MM();
            }
        }
    
        _min.x *= escala;
        _min.y *= escala;
        _min.z *= escala;
        _max.x *= escala;
        _max.y *= escala;
        _max.z *= escala;
        con_minmax = TRUE;
    }
    (*min) = _min;
    (*max) = _max;
}

void
MESH::pintar_aqz(FILE *fd)
{
    fprintf(fd, "    // Pilas: No hay pintar_aqz... \n");
    fprintf(fd, "    geometria ESFERA 1 \"\"\n");
}

void
MESH::pintar_povray(FILE *fd)
{
    float x1, y1, z1;
    float x2, y2, z2;
    float x3, y3, z3;
    //float nx1, ny1, nz1;
    //float nx2, ny2, nz2;
    //float nx3, ny3, nz3;
    int i, j;

    if ( !preprocesada ) init();

    fprintf(fd, "merge {\n");
    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {                             
        fprintf(fd, "mesh {\n");
        for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {       
           //nx1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].nx;
           //ny1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].ny;
           //nz1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].nz;
           x1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].x;
           y1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].y;
           z1 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p0].z;
           //nx2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].nx;
           //ny2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].ny;
           //nz2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].nz;
           x2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].x;
           y2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].y;
           z2 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p1].z;
           //nx3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].nx;
           //ny3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].ny;
           //nz3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].nz;
           x3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].x;
           y3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].y;
           z3 = arr_vertices[arr_trozos_gl[i].triangulos_gl[j].p2].z;

           fprintf(fd, "    triangle {<%f,%f,%f>,<%f,%f,%f>,<%f,%f,%f>}\n",
               x1*escala, y1*escala, z1*escala, x2*escala, y2*escala,
               z2*escala, x3*escala, y3*escala, z3*escala);

#ifdef NO_FUNCIONA_ESTO_EN_POV
           fprintf(fd, "    smooth_triangle {");
           fprintf(fd, "<%.4f,%.4f,%.4f>,<%.4f,%.4f,%.4f>,",
               x1*escala, nx1, y1*escala, ny1, z1*escala, nz1);
           fprintf(fd, "<%.4f,%.4f,%.4f>,<%.4f,%.4f,%.4f>,",
               x2*escala, nx2, y2*escala, ny2, z2*escala, nz2);
           fprintf(fd, "<%.4f,%.4f,%.4f>,<%.4f,%.4f,%.4f>}\n",
               x3*escala, nx3, y3*escala, ny3, z3*escala, nz3);
#endif
        }
        arr_trozos_gl[i].material.activar_povray(fd);
        fprintf(fd, "}");
    }


}

//===========================================================================

int
MESH::num_grupos(void)
{
    return arr_trozos_gl.tam();
}

long int
MESH::num_vertices(void)
{
    return arr_vertices.tam();
}

long int
MESH::num_triangulos(void)
{
    int i;
    long int accum = 0;

    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        accum += arr_trozos_gl[i].arr_triangulos.tam();
    }
    return accum;
}

void
MESH::controlar(BOOLEAN *arr_control)
{
    Arr_control = arr_control;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif 
}

void
MESH::set_pintado_normales(BOOLEAN c)
{
    pintar_normales = c;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif
}

void
MESH::set_debug_vertices(BOOLEAN c)
{
    pintar_debug_vertices = c;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif
}

void
MESH::set_debug_triangulos(BOOLEAN c)
{
    pintar_debug_triangulos = c;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif
}

void
MESH::set_debug_vertices_index(long int i)
{
    index_debug_vertice = i;
}

void
MESH::set_debug_triangulos_index(long int i)
{
    index_debug_triangulo = i;
}

void
MESH::set_material_global(BOOLEAN m)
{
    material_global = m;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif
}

void
MESH::set_debug_tiras(BOOLEAN t)
{
    mostrar_tiras = t;
  #ifdef GL_ENABLED
    preprocesada_gl = FALSE;
  #endif
}

void
MESH::imprimir(BOOLEAN full_report)
{
    int i, j, num_tri;
    long int ttt = 0;
    long int tttiras = 0;
    long int num_con_textura = 0;

    if ( !preprocesada ) init();

    //-----------------------------------------------------------------------
    for ( i = 0; i < arr_trozos_gl.tam(); i++ ) {
        if ( arr_trozos_gl[i].texturename && 
             strlen(arr_trozos_gl[i].texturename) ) {
            num_con_textura++;
        }
    }
    
    //-----------------------------------------------------------------------
    if ( full_report ) {
        printf(
"= MESH ====================================================================\n"
        );

        if ( _nombre_de_archivo ) {
            printf("  - Geometria importada del archivo \"%s\".\n", 
                   _nombre_de_archivo);
        }

        printf("  - Modo: %s %s uso de listas precompiladas OpenGL\n",
               modo_tiras_de_triangulos?"tiras de triangulos":
               "triangulos sueltos",
               con_lista_gl?"con":"sin");
      #ifdef GL_COMPLETO
        printf("  - Usando primitivas de OpenGL 1.1 (arreglos de datos)\n");
      #endif
      #ifndef GL_COMPLETO
        printf(
            "  - Usando primitivas de OpenGL 1.0 (SIN arreglos de datos)\n");
      #endif
    }

    if ( full_report ) {
        printf("  - %ld vertices en la estructura\n", num_vertices()); 
        fflush(stdout);
    }
    char cc;

    if ( arr_trozos_gl.tam() < 1 ) {
        printf("  - ESTRUCTURA VACIA!\n");
    }
    else {
        if ( full_report ) {
            if ( arr_trozos_gl.tam() == 1 ) {
                printf("  - La estructura consiste de un solo grupo\n");
            }
            else{
                printf("  - La estructura contiene %ld grupos:\n",
                    arr_trozos_gl.tam());
            }
        }
        for ( i = 0; !modo_tiras_de_triangulos && i < arr_trozos_gl.tam(); i++ ) {
            if ( full_report ) {
                if ( !Arr_control ) {
                    cc = '=';
                  }
                  else if ( Arr_control[i] ) {
                    cc = '*';
                  }
                  else {
                      cc = '.';
                  }
                ;
                printf("    [%c] Grupo %d: %ld triangulos.\n", cc, i+1,
                       arr_trozos_gl[i].arr_triangulos.tam());
            }
            ttt += arr_trozos_gl[i].arr_triangulos.tam();
        }
        for ( i = 0; modo_tiras_de_triangulos && i < arr_trozos_gl.tam(); i++ ) {
            if ( full_report ) {
                if ( !Arr_control ) {
                    cc = '=';
                  }
                  else if ( Arr_control[i] ) {
                    cc = '*';
                  }
                  else {
                    cc = '.';
                  }
                ;
                printf("    [%c] Grupo %2d: %3ld tiras, ", cc, i+1,
                       arr_trozos_gl[i].longitudes_tiras.tam());
            }
            num_tri = 0;
            for ( j = 0; j < arr_trozos_gl[i].longitudes_tiras.tam(); j++ ) {
                    //printf("%d ", arr_trozos_gl[i].longitudes_tiras[j]);
                num_tri += arr_trozos_gl[i].longitudes_tiras[j];
                tttiras++;
            }
            if ( full_report ) {
                printf("%d triangulos (%.2f triangulos por tira)\n", num_tri,
                       (double)num_tri/(double)arr_trozos_gl[i].longitudes_tiras.tam());
            }
            ttt += num_tri;
        }
    }

    if ( full_report ) {
        printf("  - %ld triangulos en total.\n", ttt);
        printf("  - %ld nombres de textura definidos.\n", num_con_textura);
        printf(
"===========================================================================\n"
        );
        printf("\n");
    }
    else {
        printf("%ld triangulos, ", ttt);
        if ( arr_trozos_gl.tam() != 1 ) {
            printf("%ld trozos, %ld referencias a textura.", 
                   arr_trozos_gl.tam(), num_con_textura);
          }
          else {
            printf("1 trozo.");
        }
        if ( modo_tiras_de_triangulos ) {
            printf(" %ld tiras, %.2f triangulos por tira, %ld referencias a textura.", tttiras,
                (double)ttt/(double)tttiras, num_con_textura);
        }
        if ( _nombre_de_archivo ) {
            printf("\t%s", _nombre_de_archivo);
        }
        printf("\n");
    }

    fflush(stdout);
}

BOOLEAN
MESH::exportar_obj(FILE *fd, int i)
{
    int j;

    fprintf(fd, "# Archivo .obj generado por AQUYNZA\n");
    for ( j = 0; j < arr_vertices.tam(); j++ ) {
        fprintf(fd, "v %f %f %f\n",
            arr_vertices[j].x, arr_vertices[j].y, arr_vertices[j].z);
    }
    fprintf(fd, "\n");
    for ( j = 0; j < arr_trozos_gl[i].arr_triangulos.tam(); j++ ) {
        // Notese que en el formato Wavefront - OBJ los indices se numeran
        // desde 1 y NO desde 0.
        fprintf(fd, 
                "f %d %d %d\n", 
                arr_trozos_gl[i].arr_triangulos[j].p0+1,
                arr_trozos_gl[i].arr_triangulos[j].p1+1,
                arr_trozos_gl[i].arr_triangulos[j].p2+1);
    }
    return TRUE;
}

void
MESH::anexar_trozo_obj(char *linea)
{
    TRIANGULO_GL t, t2, t3, t4, t5, t6, t7;
    
    //- ATENCION: Recuerde que CRAY no soporta inicializaciones aqui! -------
    t.p0  = 0;    t.p1  = 0;    t.p2  = 0;
    t2.p0 = 0;    t2.p1 = 0;    t2.p2 = 0;
    t3.p0 = 0;    t3.p1 = 0;    t3.p2 = 0;
    t4.p0 = 0;    t4.p1 = 0;    t4.p2 = 0;
    t5.p0 = 0;    t5.p1 = 0;    t5.p2 = 0;
    t6.p0 = 0;    t6.p1 = 0;    t6.p2 = 0;
    t7.p0 = 0;    t7.p1 = 0;    t7.p2 = 0;

    //-----------------------------------------------------------------------
    char *ptr;
    LISTA <char*> tokens;
    int i;

    //-----------------------------------------------------------------------
    for ( ptr = strtok(linea, " \t\n"); ptr; ptr = strtok(NULL, " \t\n") ) {
        tokens.anx(ptr);
    }
    for ( i = 0; i < (int)strlen(linea); i++ ) {
        if ( linea[i] == '/' ) linea[i] = ' ';
    }

    for ( i = 0; i < tokens.tam(); i++ ) {
        switch ( i ) {
          case 0: break;
          case 1: t.p0 = atoi(tokens[i]) - 1; break;
          case 2: t.p1 = atoi(tokens[i]) - 1; break;
          case 3: t.p2 = atoi(tokens[i]) - 1; break;
          case 4:
            t2.p0 = t.p0;
            t2.p1 = t.p2;
            t2.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t2, "WG_DEFAULT");
            break;
          case 5:
            t3.p0 = t2.p0;
            t3.p1 = t2.p2;
            t3.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t3, "WG_DEFAULT");
            break;
          case 6:
            t4.p0 = t3.p0;
            t4.p1 = t3.p2;
            t4.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t4, "WG_DEFAULT");
            break;
          case 7:
            t5.p0 = t4.p0;
            t5.p1 = t4.p2;
            t5.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t5, "WG_DEFAULT");
            break;
          case 8:
            t6.p0 = t5.p0;
            t6.p1 = t5.p2;
            t6.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t6, "WG_DEFAULT");
            break;
          case 9:
            t7.p0 = t6.p0;
            t7.p1 = t6.p2;
            t7.p2 = atoi(tokens[i]) - 1;
            anx_triangle(t7, "WG_DEFAULT");
            break;
          default: break;
        }
    }
    anx_triangle(t, "WG_DEFAULT");
    tokens.elim();
}

BOOLEAN
MESH::importar_obj(char *archivo, double *Escala_optima)
{
    FILE *fd;
    char linea[1024];

    //- Abra el archivo -----------------------------------------------------
    fd = fopen(archivo, "rt");
    if ( !fd ) {
        fprintf(stderr, "ERROR: No se puede abrir el archivo!\n");
        fflush(stderr);
        return FALSE;
    }
    set_nombre_de_archivo(archivo);

    // Esto es para calcular el factor de escala optima
    VECTOR min, max, factor;
    VECTOR accum(0, 0, 0);

    min.x = INFINITO;
    min.y = INFINITO;
    min.z = INFINITO;
    max.x = -INFINITO;
    max.y = -INFINITO;
    max.z = -INFINITO;

    //printf("Importando OBJ...\n"); fflush(stdout);

    //-----------------------------------------------------------------------
    COLOR ambient, diffuse, specular;

    //- Felizmente es barato tener oro en la realidad virtual :-)
    ambient.r = ambient.g = ambient.b = 0.2f;
    diffuse.r = 0.85f;
    diffuse.g = 0.85f;
    diffuse.b = 0.1f;
    specular.r = specular.g = specular.b = 1.0;
    ambient.alpha = diffuse.alpha = specular.alpha = 1.0;
    anx_material(ambient, diffuse, specular, "WG_DEFAULT", "", 0);

    //- Cree la estructura --------------------------------------------------
    VECTOR e;
    MATRIZ_4x4 R;
    VERTICE_GL v;
    char *ptr;

    // OJO: Wavefront, respecto a AQUYNZA, suele ver sus coordenadas 90
    //      grados volteada...
    R.rotacion_angulos_euler(DEG2RAD(-90), 0, DEG2RAD(90)); 

    while ( fgets(linea, 1023, fd) ) {
        if ( linea[0] == 'v' && linea[1] == ' ' ) {
            // Leo e
            ptr = strtok(linea, " \t\n");
            ptr = strtok(NULL, " \t\n");
            e.x = atof(ptr);
            ptr = strtok(NULL, " \t\n");
            e.y = atof(ptr);
            ptr = strtok(NULL, " \t\n");
            e.z = atof(ptr);
            e = R * e;
            accum = accum + e;

            // Calculo el vertice
            v.x = (float)e.x;
            v.y = (float)e.y;
            v.z = (float)e.z;

            //e.normalizar();  // OJO!
            //v.nx = e.x;
            //v.ny = e.y;
            //v.nz = e.z;

            // Llevo los extremos
            if ( v.x < min.x ) min.x = v.x;
            if ( v.y < min.y ) min.y = v.y;
            if ( v.z < min.z ) min.z = v.z;
            if ( v.x > max.x ) max.x = v.x;
            if ( v.y > max.y ) max.y = v.y;
            if ( v.z > max.z ) max.z = v.z;

            anx_vertex(v);
        }       
        if ( linea[0] == 'f' && linea[1] == ' ' ) {
            anexar_trozo_obj(linea);
        }
    }

    //-----------------------------------------------------------------------
    VECTOR p;
    VECTOR o(0, 0, 0);
    int i;
    double theta, phi;

    factor = max - min;
    *(Escala_optima) = 5/factor.norma();
    //o = accum/arr_vertices.tam();
    //o = (max + min) / 2;

    // Estimo las coordenadas de la textura!
    for ( i = 0; i < arr_vertices.tam(); i++ ) {
        // Se calcula u
        p.x = arr_vertices[i].x;
        p.y = arr_vertices[i].y;
        p.z = arr_vertices[i].z;
        p = p - o;
        p.normalizar();

        phi = acos(p.z);
        if ( fabs(sin(phi)) < EPSILON ) theta = 0;
        if ( p.y > -EPSILON ) theta = acos(p.x/sin(phi));
        else theta = 2*PI - acos(p.x/sin(phi));

        theta /= 2*PI;
        phi /= -PI;
        while( phi < 0 ) phi += 1;
        while( theta < 0 ) theta += 1;
        while( phi > 1 ) phi -= 1;
        while( theta > 1 ) theta -= 1;
        //

        //arr_vertices[i].u = (float)(p.y - o.y) / (max.y - min.y) + 0.5;
        arr_vertices[i].u = (float)(theta);

        // Se calcula v
        //arr_vertices[i].v = (float)(p.z - o.z)/(max.z - min.z) + 0.5;
        arr_vertices[i].v = (float)(phi);
    }
    //calcular_normales = FALSE; // OJO: Solo si quiero enviromental map!

    calcular_normales = TRUE;

    return TRUE;
}

//===========================================================================
//= 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.