md2load.C

Ir a la documentación de este archivo.

//===========================================================================
//= md2load.cc                                            Noviembre de 1999 =
//=-------------------------------------------------------------------------=
//= Modulo de importacion de datos de avatares QUAKE2 en formato MD2        =
//=-------------------------------------------------------------------------=
//= ADVERTENCIA: ESTE SOFTWARE NO ESTA CONCEBIDO NI DISENNADO PARA EL USO   =
//= EN EQUIPO DE CONTROL EN LINEA EN ENTORNOS PELIGROSOS QUE REQUIERAN UN   =
//= DESEMPENNO LIBRE DE FALLAS, COMO LA OPERACION DE PLANTAS NUCLEARES,     = 
//= SISTEMAS DE NAVEGACION O COMUNICACION EN AVIONES, TRAFICO AEREO,        =
//= EQUIPO MEDICO DEL CUAL DEPENDAN VIDAS HUMANAS O SISTEMAS DE ARMAMENTO,  =
//= EN LOS CUALES UNA FALLA EN EL SOFTWARE PUEDA IMPLICAR DIRECTAMENTE LA   =
//= MUERTE, DANNOS PERSONALES O DANNOS FISICOS Y/O AMBIENTALES GRAVES       =
//= ("ACTIVIDADES DE ALGO RIESGO").                                         =
//=-------------------------------------------------------------------------=
//= Autor original: Oscar J. Chavarro G.  A.K.A. JEDILINK. Copyright (c),   =
//= 1997 - 2003, oscarchavarro@hotmail.com                                  =
//= AQUYNZA es software libre, y se rige bajo los terminos de la licencia   =
//= LGPL de GNU (http://www.gnu.org). Para mayor informacion respecto a la  =
//= licencia de uso, consulte el archivo ./doc/LICENCIA en la distribucion. =
//===========================================================================

#include "jed_defs.h"
#include "toolkits/util/md2load.h"
#include "lista.cc"

#include <string.h>

static void
leer_bytes(FILE *f, void *buffer, int count) { fread (buffer, 1, count, f); }

#define MAX_TRIANGLES 4096
#define MAX_VERTS 2048
#define MAX_FRAMES 512
#define MAX_SKINNAME 64

//===========================================================================
//= Estructuras privadas usadas en el proceso de importacion de datos       =
//===========================================================================

class COORDENADA_PIEL_MD2 {
  public:
    WORD s;
    WORD t;
};

class POLIGONO_MD2
{
  public:
    WORD index_xyz[3];
    WORD index_st[3];
};

class N_MD2
{
  public:
    BYTE v[3];
    BYTE lightnormalindex;
};

class FRAME_ALIAS
{
  public:
    float scale[3];
    float translate[3];
    char name[16];
    N_MD2 verts[1];
};

class ENCABEZADO_MD2
{
  public:
    DWORD id_md2;       // Identificadores del formato de archivo MD2
    DWORD version;
    DWORD piel_xtam;    // Inforacion de las configuraciones MESH
    DWORD piel_ytam;
    DWORD framesize;
    DWORD num_pieles;   //
    DWORD num_vertices;
    DWORD _num_st;
    DWORD num_triangulos;
    DWORD _num_glcmds;
    DWORD num_frames;
    DWORD ofs_skins;    //
    DWORD ofs_st;
    DWORD ofs_tris;
    DWORD ofs_frames;
    DWORD ofs_glcmds; 
    DWORD ofs_end;
};

//===========================================================================
//= Clase
//===========================================================================

LECTOR_QUAKE_MD2::LECTOR_QUAKE_MD2()
{
    triangulos_arr = NULL;
    frames_arr = NULL;
    _num_frames = 0;
    _num_vertices = 0;
    _num_triangulos = 0;
    _nombre_piel = NULL;
    Piel = NULL;
}

LECTOR_QUAKE_MD2::~LECTOR_QUAKE_MD2()
{
    elim();
}

void
LECTOR_QUAKE_MD2::elim(void)
{
    DWORD i;

    if ( frames_arr ) {
        for ( i = 0; i < _num_frames; i++ ) delete frames_arr[i].arr_vertices;
        delete frames_arr;
        frames_arr = NULL;
    }
    if ( triangulos_arr ) {
        delete triangulos_arr;
        triangulos_arr = NULL;
    }
    if ( _nombre_piel ) {
        delete _nombre_piel;
        _nombre_piel = NULL;
    }
    // OJO: La textura no es de esta clase! Es de la MESH! No hacer delete Piel
}

BOOLEAN
LECTOR_QUAKE_MD2::leer(char *archivo_md2, char *archivo_piel, 
                  double factor_gamma)
{
    //- Cargue la textura para su piel --------------------------------------
    FILE *fd = fopen(archivo_piel, "rb");
    if ( !fd ) {
        fprintf(stderr,"<LECTOR_QUAKE_MD2> ERROR: no puedo abrir el archivo %s!\n",
            archivo_piel);
        fflush(stderr);
        return FALSE;
    }
    Piel = new IMAGEN_RGB();
    if ( !Piel || !Piel->importar_pcx(fd) ) {
        fprintf(stderr,"ERROR Abriendo la imagen.\n"); fflush(stderr);
        exit(1);
    }

    BYTE funcion_gamma[256];

    calcular_funcion_gamma(funcion_gamma, factor_gamma);
    Piel->aplicar_correccion_gamma(funcion_gamma);

    _nombre_piel = new char[strlen(archivo_piel)+1];
    strcpy(_nombre_piel, archivo_piel);

    //- Abra el archivo y lea el encabezado MD2 -----------------------------
    ENCABEZADO_MD2      encabezado;

    fd = fopen (archivo_md2, "rb");
    if ( !fd ) {
        fprintf(stderr,"<LECTOR_QUAKE_MD2> ERROR: No puedo abrir el archivo %s!\n",
            archivo_md2);
        fflush(stderr);
        return FALSE;
    }

    lea_DWORD_BE(&encabezado.id_md2, fd);
    lea_DWORD_BE(&encabezado.version, fd);
    lea_DWORD_BE(&encabezado.piel_xtam, fd);
    lea_DWORD_BE(&encabezado.piel_ytam, fd);
    lea_DWORD_BE(&encabezado.framesize, fd);
    lea_DWORD_BE(&encabezado.num_pieles, fd);
    lea_DWORD_BE(&encabezado.num_vertices, fd);
    lea_DWORD_BE(&encabezado._num_st, fd);
    lea_DWORD_BE(&encabezado.num_triangulos, fd);
    lea_DWORD_BE(&encabezado._num_glcmds, fd);
    lea_DWORD_BE(&encabezado.num_frames, fd);
    lea_DWORD_BE(&encabezado.ofs_skins, fd);
    lea_DWORD_BE(&encabezado.ofs_st, fd);
    lea_DWORD_BE(&encabezado.ofs_tris, fd);
    lea_DWORD_BE(&encabezado.ofs_frames, fd);
    lea_DWORD_BE(&encabezado.ofs_glcmds, fd) 
    lea_DWORD_BE(&encabezado.ofs_end, fd);

    //- Cree la estructura de representacion del MESH y sus configuraciones -
    DWORD i, j;

    _num_frames     = encabezado.num_frames;
    _num_vertices   = encabezado.num_vertices;
    _num_triangulos = encabezado.num_triangulos;
    triangulos_arr  = new TRIANGULO_QUAKE [_num_triangulos];
    frames_arr      = new CONFIGURACION_MESH [_num_frames];

    for ( i = 0; i < _num_frames; i++ ) {
        frames_arr[i].arr_vertices = new VERTICE_GL[_num_vertices];
    }

    //- Llene los datos del mesh --------------------------------------------
    char *nombres_pieles;
    COORDENADA_PIEL_MD2 *puntos_uv =
        new COORDENADA_PIEL_MD2[encabezado._num_st];
    POLIGONO_MD2 tri;

    nombres_pieles = new char [encabezado.num_pieles * MAX_SKINNAME];
    leer_bytes(fd, nombres_pieles, encabezado.num_pieles * MAX_SKINNAME);
    for ( i = 0; i < encabezado._num_st; i++ ) {
        lea_WORD_BE(&puntos_uv[i].s, fd);
        lea_WORD_BE(&puntos_uv[i].t, fd);
    }

    for ( i = 0; i < _num_triangulos; i++ ) {
        lea_WORD_BE(&tri.index_xyz[0], fd);
        lea_WORD_BE(&tri.index_xyz[1], fd);
        lea_WORD_BE(&tri.index_xyz[2], fd);
        lea_WORD_BE(&tri.index_st[0], fd);
        lea_WORD_BE(&tri.index_st[1], fd);
        lea_WORD_BE(&tri.index_st[2], fd);
        triangulos_arr[i].p0 = tri.index_xyz[2];
        triangulos_arr[i].p1 = tri.index_xyz[1];
        triangulos_arr[i].p2 = tri.index_xyz[0];
        triangulos_arr[i].a_s = puntos_uv[tri.index_st[2]].s;
        triangulos_arr[i].a_t = puntos_uv[tri.index_st[2]].t;
        triangulos_arr[i].b_s = puntos_uv[tri.index_st[1]].s;
        triangulos_arr[i].b_t = puntos_uv[tri.index_st[1]].t;
        triangulos_arr[i].c_s = puntos_uv[tri.index_st[0]].s;
        triangulos_arr[i].c_t = puntos_uv[tri.index_st[0]].t;
    }
    delete puntos_uv;
    delete nombres_pieles;

    //-----------------------------------------------------------------------
    BYTE        buffer[MAX_VERTS*4+128];
    FRAME_ALIAS *out;

    for ( i = 0; i < _num_frames; i++ ) {
        out = (FRAME_ALIAS *)buffer;
        leer_bytes(fd, out, encabezado.framesize);
        for ( j = 0; j < _num_vertices; j++ ) {
            frames_arr[i].arr_vertices[j].x =
                out->verts[j].v[0] * out->scale[0] + out->translate[0];
            frames_arr[i].arr_vertices[j].y =
                out->verts[j].v[1] * out->scale[1] + out->translate[1];
            frames_arr[i].arr_vertices[j].z =
                out->verts[j].v[2] * out->scale[2] + out->translate[2];
            frames_arr[i].arr_vertices[j].u = -INFINITO;
            frames_arr[i].arr_vertices[j].v = -INFINITO;
        }
    }
    fclose (fd);

    return TRUE;
}

void
LECTOR_QUAKE_MD2::init(BOOLEAN suavizar_normales)
{
    DWORD i, j;
    VERTICE_GL *Geometria_nueva, *Consulta;
    long int tam_consulta;

    printf("<LECTOR_QUAKE_MD2> Preprocesando %ld cuadros:\n[", _num_frames);
    fflush(stdout);
    for ( i = 0; i < _num_frames; i++ ) {
        printf("."); fflush(stdout);
        MESH *Tmp = exportar_MESH(i);
        // Calcule las normales para el i-esimo frame usando el MESH Tmp.
        Tmp->get_vertices(&Consulta, &tam_consulta);
        actualizar_vertices(Consulta, tam_consulta, i);
        Tmp->init();
        if ( suavizar_normales ) Tmp->promediar_normales_vertice();

        // Almacene las normales en mi i-esima geometria preprocesada
        Geometria_nueva = new VERTICE_GL[_num_triangulos * 3];
        for ( j = 0;
              j < (DWORD)tam_consulta && j < _num_triangulos * 3; j++ ) {
            Geometria_nueva[j] = Consulta[j];
        }
        geometrias_preprocesadas.anx(Geometria_nueva);
        delete Tmp;
    }
    printf("]\nOk!\n"); fflush(stdout);
    //delete Tmp; // OJO: Saca segmentation fault!
}

DWORD LECTOR_QUAKE_MD2::num_frames(void) {return _num_frames;}
DWORD LECTOR_QUAKE_MD2::num_vertices(void) {return _num_vertices;}
DWORD LECTOR_QUAKE_MD2::num_triangulos(void){return _num_triangulos;}

#ifdef NONONO
void
LECTOR_QUAKE_MD2::pintar_gl(DWORD frame)
{
    if ( frame >= _num_frames || frame < 0 ) return;

    //--- Configuracion de la textura que conforma la piel -------------------
    static float modo_repetir[] = {GL_CLAMP};
    static GLfloat f_combinar[] = {GL_MODULATE};
    static GLfloat f_interpolar[] = {GL_LINEAR};

    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, modo_repetir);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, modo_repetir);
    glTexEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, f_combinar);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, f_interpolar);
    glTexParameterfv(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, f_interpolar);
    Piel->activar_gl();
    glEnable(GL_TEXTURE_2D);

    //---
    glScaled(0.05, 0.05, 0.05); // OJO!
    glDisable(GL_LIGHTING);     // OJO!
    glColor3d(1, 1, 1);         // OJO!

    //- Generacion de una MESH ----------------------------------------------
    DWORD i;

    for ( i = 0; i < _num_triangulos; i++ ) {
      glBegin(GL_TRIANGLES);
        glTexCoord2f((triangulos_arr[i].a_s)/(float)Piel->xtam(),
                     (triangulos_arr[i].a_t)/(float)Piel->ytam());
        glVertex3f(frames_arr[frame].arr_vertices[triangulos_arr[i].p0].x,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p0].y,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p0].z);
        glTexCoord2f((triangulos_arr[i].b_s)/(float)Piel->xtam(), 
                     (triangulos_arr[i].b_t)/(float)Piel->ytam());
        glVertex3f(frames_arr[frame].arr_vertices[triangulos_arr[i].p1].x,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p1].y,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p1].z);
        glTexCoord2f((triangulos_arr[i].c_s)/(float)Piel->xtam(), 
                     (triangulos_arr[i].c_t)/(float)Piel->ytam());
        glVertex3f(frames_arr[frame].arr_vertices[triangulos_arr[i].p2].x,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p2].y,
                   frames_arr[frame].arr_vertices[triangulos_arr[i].p2].z);
      glEnd();
    }

    glDisable(GL_TEXTURE_2D); // OJO!
}
#endif

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

void
LECTOR_QUAKE_MD2::actualizar_vertices(VERTICE_GL *V,
                                      long int /*t*/, int cuadro)
{
    WORD i;
    int j;

    for ( i = 0, j = 0; i < (WORD)_num_triangulos; i++ ) {
        V[j] = 
            frames_arr[cuadro].arr_vertices[triangulos_arr[i].p0];
        V[j].u = triangulos_arr[i].a_s / (float)Piel->xtam();
        V[j].v = triangulos_arr[i].a_t / (float)Piel->ytam();
        j++;

        V[j] =
            frames_arr[cuadro].arr_vertices[triangulos_arr[i].p1];
        V[j].u = triangulos_arr[i].b_s / (float)Piel->xtam();
        V[j].v = triangulos_arr[i].b_t / (float)Piel->ytam();
        j++;

        V[j] =
            frames_arr[cuadro].arr_vertices[triangulos_arr[i].p2];
        V[j].u = triangulos_arr[i].c_s / (float)Piel->xtam();
        V[j].v = triangulos_arr[i].c_t / (float)Piel->ytam();
        j++;
    }
}

void
LECTOR_QUAKE_MD2::actualizar_vertices_rapido(VERTICE_GL *V,
                                             long int /*t*/, int cuadro)
{
    WORD i;

    if ( !geometrias_preprocesadas.tam() ) {
        fprintf(stderr, "<LECTOR_QUAKE_MD2> ERROR: Debe llamarse init() "
            "antes de usar actualizar_vertices_rapido.\n");
        fflush(stderr);
        return;
    }

    VERTICE_GL *O = geometrias_preprocesadas[cuadro];

    for ( i = 0; i < (WORD)_num_triangulos * 3; i++ ) {
        V[i] = O[i];
    }
}

#define INTERPOLAR_VARIABLE(v, vi, vf, f, t) \
( v = (float)(vi + ((double)f) * ( (vf - vi) / ((double)t) )) )

void
interpolar_vertice(VERTICE_GL *D, VERTICE_GL *Oi,
                   VERTICE_GL *Of, int f, int t)
{
    INTERPOLAR_VARIABLE(D->x, Oi->x, Of->x, f, t);
    INTERPOLAR_VARIABLE(D->y, Oi->y, Of->y, f, t);
    INTERPOLAR_VARIABLE(D->z, Oi->z, Of->z, f, t);
    INTERPOLAR_VARIABLE(D->nx, Oi->nx, Of->nx, f, t);
    INTERPOLAR_VARIABLE(D->ny, Oi->ny, Of->ny, f, t);
    INTERPOLAR_VARIABLE(D->nz, Oi->nz, Of->nz, f, t);
    D->u = Oi->u;
    D->v = Oi->v;
}

void
LECTOR_QUAKE_MD2::actualizar_vertices_rapido_i(VERTICE_GL *V,
                                             long int /*t*/, int cuadro,
                                             int cuadroi, int cuadrof,  
                                             int frame, int tam)
{
    WORD i;

    if ( !geometrias_preprocesadas.tam() ) {
        fprintf(stderr, "<LECTOR_QUAKE_MD2> ERROR: Debe llamarse init() "
            "antes de usar actualizar_vertices_rapido.\n");
        fflush(stderr);
        return;
    }

    VERTICE_GL O, *Oi, *Of;
    int elcuadro = cuadro+1;

    if ( elcuadro > cuadrof ) {
        elcuadro = cuadroi;
    }

    Oi = geometrias_preprocesadas[cuadro];
    Of = geometrias_preprocesadas[elcuadro];

    for ( i = 0; i < (WORD)_num_triangulos * 3; i++ ) {
        interpolar_vertice(&O, &Oi[i], &Of[i], frame, tam);
        V[i] = O;
    }
}

MESH *
LECTOR_QUAKE_MD2::exportar_MESH(int cuadro)
{
    WORD i;

    //- Creo una copia... (version ingenua, ineficiente en espacio) ---------
    // OJO: Esto funciona pero es muy ineficiente en espacio... ocupa 
    //      muchos mas vertices (i.e. de 300 pasa a 1800)
    VERTICE_GL *Copia_vertices = new VERTICE_GL[_num_triangulos * 3];
    TRIANGULO_GL *Copia_triangulos = new TRIANGULO_GL[_num_triangulos];

    int j;
    // Defino la topologia
    for ( i = 0, j = 0; i < (WORD)_num_triangulos; i++ ) {
        Copia_triangulos[i].p0 = j;        j++;
        Copia_triangulos[i].p1 = j;        j++;
        Copia_triangulos[i].p2 = j;        j++;
    }

    // Defino la geometria
    actualizar_vertices(Copia_vertices, _num_triangulos*3, cuadro);

    //-----------------------------------------------------------------------
    MESH *G = new MESH(181 /*umbral*/, FALSE/*strip*/, TRUE/*centrar*/, 0.05);

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

    ambient.r = ambient.g = ambient.b = 0.2f;  // ORO
    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;
    G->anx_material(ambient, diffuse, specular, "WG_DEFAULT", "", 1);

    //- Exporte la geometria y la topologia de la malla ----------------------
    VERTICE_GL v;

    for ( i = 0; i < (WORD)_num_triangulos*3; i++ ) {
        v.x = Copia_vertices[i].x;
        v.y = Copia_vertices[i].y;
        v.z = Copia_vertices[i].z;
        v.u = Copia_vertices[i].u;
        v.v = Copia_vertices[i].v;
        G->anx_vertex(v);
    }

    for ( i = 0; i < (WORD)_num_triangulos; i++ ) {
        G->anx_triangle(Copia_triangulos[i], "WG_DEFAULT");
    }

    //- Asocie la imagen ----------------------------------------------------
    G->anexar_textura(Piel);

    //-----------------------------------------------------------------------
    delete Copia_vertices;
    Copia_vertices = NULL;
    delete Copia_triangulos;
    Copia_triangulos = NULL;
    G->set_material_global(TRUE);
    return G;
}


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