3dsload.C

Ir a la documentación de este archivo.

//===========================================================================
//= 3dsload.h                         Septiembre de 1998, noviembre de 1999 =
//=-------------------------------------------------------------------------=
//= Sistema de lectura de archivos binarios en formato Autodesk-3DS.        =
//=-------------------------------------------------------------------------=
//= 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").                                         =
//=-------------------------------------------------------------------------=
//= Codigo original:                                                        =
//=  3D Studio object reader by David Farrell, fdavid@cyberramp.net         =
//= Modificado por Oscar J. Chavarro G.            oscarchavarro@hotmail.co =
//===========================================================================

#include <stdio.h>
#include <stdlib.h>
#include <string.h>
#include "toolkits/util/3dsload.h"
#include "matriz4.h"
#include "arreglo.cc"

//===========================================================================
//= Constantes y macros                                                     =
//===========================================================================

//#define DEBUG_3DS 1

#define COMPARAR_MM()                           \
        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;

#define ADVERTIR_FALLAS()                                                 \
    if ( Scene->flag_material_por_defecto ) {                             \
printf("\n");                                                             \
printf("WARNING: This model uses default materials. 3D Studio saves no\n" \
"       information about default materials, so View3DS substitutes\n"    \
"       an all-white material in its place. Therefore, some of the\n"     \
"       model may appear as bright white. To fix this, name each\n"       \
"       material in 3D Studio.\n");                                       \
    }                                                                     \
    if ( Scene->flag_caras_dobles ) {                                     \
printf("\n");                                                             \
printf("WARNING: This model contains double-sided polygons.\n"            \
"         The number of triangles in this model has now\n"                \
"         DOUBLED. If possible, re-do the model in\n"                     \
"         3D Studio without double-sided materials.\n"                    \
"         Use a normal threshold of at least 90.\n"                       \
"         Also, stripification will not work properly.\n");               \
    }                                                                     \
    printf("\n");

#define VERIFICAR(p)                                                    \
    if ( !(p) ) {                                                       \
        fprintf(stderr, "<ESCENA_3DS> ERROR Asignando memoria!\n");     \
        fflush(stderr);                                                 \
        exit(1);                                                        \
    }

//===========================================================================
//= Variables globales                                                      =
//===========================================================================

static char *  ULTIMO_archivo = NULL;

//===========================================================================
//= Funciones utilitarias                                                   =
//===========================================================================

static void
dsetpos(DWORD pos, FILE *fd)
{
    if( fseek(fd, (long)pos, SEEK_SET) != 0 ) {
        fprintf(stderr, "<3DS_LOAD> - ERROR FATAL posicionando dentro de\n"
                "    \"%s\".", ULTIMO_archivo);
        fflush(stderr);
        exit(1);
    }
}

static DWORD
dgetpos(FILE *fd)
{
    long pos;
    if( (pos=ftell(fd)) == -1L ) {
        fprintf(stderr, "Error getting fileposition\n");
        fflush(stderr);
    }

    return (DWORD) pos;
}

//===========================================================================
//= CLASE MESH_3DS                                                          =
//===========================================================================

MESH_3DS::MESH_3DS() /*: arr_jed(1)*/
{
    // OJO: La idea era cambiar esto por arr_jed... pero NI IDEA de porque eso
    //      no canciona!... el tipo simplemente se muere!
    jed_arr = NULL;
    jed_tam = 0;
    con_matriz = FALSE;
}


void
MESH_3DS::asignar_material_por_defecto(WORD nf)
/* WG function*/
{
    MATERIAL_ARR *binding;
    int n;
    unsigned long int nn;

    binding = anx_data();

    /* The material name is first */
    strcpy(binding->name, "WG_DEFAULT");

    /* Then the number of faces */
    nn = 0x0000FFFFL & (unsigned long int)nf;
    binding->NumFaces = (unsigned int)nn;
    binding->faces = new UWORD[(unsigned int)nn];

    /* Bind the faces to the material */
    for ( n = 0; n < nf; n++ ) {
        binding->faces[n] = (unsigned short)n; // OJO!
    }

  #ifdef DEBUG_3DS
    printf(" Read Material %s with %d faces\n", name, nf);
  #endif
} 

//= Metodos de lectura (leer_trozo_*) =======================================

void
MESH_3DS::leer_trozo_VERTLIST(void)
{
    UWORD nv;
    unsigned int n;

    lea_WORD_BE(&nv, fd);
    vertices_tam = nv;

    vertices_arr = new VERTLIST_DATA[nv];
    VERIFICAR(vertices_arr);
    for( n = 0; n < nv; n++ ) {
        lea_FLOAT32_BE(&vertices_arr[n].x, fd);
        lea_FLOAT32_BE(&vertices_arr[n].y, fd);
        lea_FLOAT32_BE(&vertices_arr[n].z, fd);
    }

  #ifdef DEBUG_3DS
    printf("  - Read Vertex List with %d vertices\n", nv);
  #endif
}

WORD
MESH_3DS::leer_trozo_FACELIST(void)
{
    WORD nv;
    WORD swap;
    WORD n;
    DWORD mm;

    lea_WORD_BE(&nv, fd);
    mm = 0x0000FFFFL & (unsigned long int)nv;
    nv = (unsigned int)mm;

    NumFaces = (unsigned int)nv;

    /* OJO: nv es unsigned int, nunca va a ocurrir esto!
    if ( nv < 0 ) {
        fprintf(stderr, "<MESH_3DS> Error de representacion numerica.\n");
        fprintf(stderr, "  - La geometria deberia tener un numero positivo\n"
        "    de triangulos, pero la rutina de lectura entendio %ld.\n",
                (long)nv);
        fflush(stderr);
        exit(-666);
    }
    */

    facelist = new FACELIST_DATA[nv];
    VERIFICAR(facelist);
    for( n = 0; n < nv; n++ ) {
        lea_WORD_BE(&facelist[n].p0, fd);
        lea_WORD_BE(&facelist[n].p1, fd);
        lea_WORD_BE(&facelist[n].p2, fd);
        lea_WORD_BE(&facelist[n].flags, fd);
        /* 0x07 means that the AB, BC, and CA edges are all wound 
         * in the reverse order, so swap the last two vertices */
        // OJO! Esta vaina no tiene sentido!
        /*
        La idea es que los 3 bits menos significativos de `flags` tienen
        las orientaciones de los lados AB, BC y CA del triangulo actual...
        si 3ds fuera decente, eso siempre seria 0x00 o en el peor de los
        casos 0x03, pero los demas casos... NO TIENEN SENTIDO!
        */
        if ( facelist[n].flags == 0x07 ) {
        //if ( (facelist[n].flags & 0x01) ) { // Esta condicion supone que la
                                            // orientacion del triangulo esta
                                            // dada por la orientacion de su
                                            // primer lado (AB). --> MAL!
            swap = facelist[n].p1;
            facelist[n].p1 = facelist[n].p2;
            facelist[n].p2 = swap;
        }
    }

  #ifdef DEBUG_3DS
    printf("  - Read Face List with %d faces\n", nv);
  #endif

    return nv; /* WG */
}

void
MESH_3DS::leer_trozo_MAPLIST(void)
/* Reads in the mapping list/texture coords. for the current mesh object */
{
    unsigned int nv;
    unsigned int n;
    unsigned long int nn;

    lea_WORD_BE(&nv, fd);
    nn = 0x0000FFFFL & (unsigned long int)nv;
    nv = (unsigned int)nn;
    NumMaps=nv;

    maplist = new MAPLIST_DATA[nv];
    VERIFICAR(maplist);
    for(n=0; n<nv; n++) {
        lea_FLOAT32_BE(&maplist[n].u, fd);
        lea_FLOAT32_BE(&maplist[n].v, fd);
    }

  #ifdef DEBUG_3DS
    printf(" Read Map List with %d maps\n", nv);
  #endif
}

void
MESH_3DS::leer_trozo_TRMATRIX(void)
/*Reads in the translation matrix for the current mesh object.
  I'm not sure when this is used in a 3DS model. */
{
    int i;
    for ( i = 0; i < 12; i++ ) {
        lea_FLOAT32_BE(&TraMatrix[i], fd);
    }
    con_matriz=TRUE;

  #ifdef DEBUG_3DS
    printf("  - Read Translation Matrix\n");
    printf("      %4.4f %4.4f %4.4f %4.4f\n",
           TraMatrix[0], TraMatrix[3], TraMatrix[6], TraMatrix[9]);
    printf("      %4.4f %4.4f %4.4f %4.4f\n",
           TraMatrix[1], TraMatrix[4], TraMatrix[7], TraMatrix[10]);
    printf("      %4.4f %4.4f %4.4f %4.4f\n",
           TraMatrix[2], TraMatrix[5], TraMatrix[8], TraMatrix[11]);
  #endif
}

void
MESH_3DS::leer_trozo_FACEMAT(void)
/*Assigns the material in this chunk to the faces specified. 
  Each material has a list of indexes into the face array to
  mark which faces use which material. */
/* Changed word nf; word face; to uword's
 * Thanks to Eran Gottlieb */
{
    UWORD nf;
    UWORD face;
    char name[50];
    MATERIAL_ARR *binding;
    int i;

    binding = anx_data();

    // Lea el nombre del material, es una cadena terminada en '\0'
    i = 0;
    do {
        lea_BYTE(&name[i++], fd);
    } while( name[i-1] != '\0' && i < (int)sizeof(name) );
    name[i-1]='\0';
    strcpy(binding->name, name);

    /* Then the number of faces */
    lea_WORD_BE(&nf, fd);
    binding->NumFaces = (unsigned int)nf;
    binding->faces = new UWORD[nf];

    /* Bind the faces to the material */
    for ( i = 0; i < nf; i++ ) {
        lea_WORD_BE(&face, fd);
        binding->faces[i] = face;
    }

  #ifdef DEBUG_3DS
    printf("  - Read Material \"%s\" with %d faces\n", name, nf);
  #endif
} 

//===========================================================================
//= Funciones que leen trozos de nivel 4                                    =
//= Los metodos de la clase MESH_3DS tambien manejan lecturas de nivel 4    =
//===========================================================================

void
ESCENA_3DS::leer_trozo_MAPFILENAME(DWORD /*p*/, TEXTURE_DATA *texture)
{
    int n;
    char name[MAXNAMESIZE];

    n = 0;
    do {
        lea_BYTE(&name[n++], fd);
    } while( name[n-1] != '\0' && n < (int)sizeof(name) );
    name[n-1]='\0';
  
    strcpy(texture->texturename, name);

  #ifdef DEBUG_3DS
    printf("  - Read Texture Name: %s\n", name);
  #endif
}

void
ESCENA_3DS::leer_trozo_AMOUNT(WORD *amount)
{
    WORD temp;

    lea_WORD_BE(&temp, fd);
    *amount = temp;
}

void
ESCENA_3DS::leer_trozo_RGBByte(COLOR *rgb) 
/* Reads in an RGB byte triplet */
{
    BYTE red, green, blue;

    lea_BYTE(&red, fd);
    lea_BYTE(&green, fd);
    lea_BYTE(&blue, fd);
    rgb->r = (float)(red)/256.0f;
    rgb->g = (float)(green)/256.0f;
    rgb->b = (float)(blue)/256.0f;

  #ifdef DEBUG_3DS
    printf("  - Tripla RGB_BYTE: <%f, %f, %f>\n", rgb->r, rgb->g, rgb->b);
  #endif
}

void
ESCENA_3DS::leer_trozo_RGBFloat(COLOR *rgb)
/* Reads in an RGB FP triplet */
{
    lea_FLOAT32_BE(&rgb->r, fd);
    lea_FLOAT32_BE(&rgb->g, fd);
    lea_FLOAT32_BE(&rgb->b, fd);

  #ifdef DEBUG_3DS
    printf("  - Tripla RGB_FLOAT: <%f, %f, %f>\n", rgb->r, rgb->g, rgb->b);
  #endif
}

//===========================================================================
//= Funciones que leen trozos de nivel 3 - control de trozos de nivel 4     =
//===========================================================================

void
ESCENA_3DS::leer_trozo_TEXTURE(DWORD p, TEXTURE_DATA *texture)
{
    UWORD id;
    DWORD len, pc;

    while((pc=dgetpos(fd)) < p) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch((unsigned int)id) {
          case CHUNK3DS_MAPFILENAME: 
            leer_trozo_MAPFILENAME(pc+len, texture); 
            break;
          default: 
            dsetpos(pc+len, fd);
        }
    }
}  

void
ESCENA_3DS::leer_trozo_TRANSPARENCY(DWORD p, FLOAT32 *alpha)
/* I interpret the transparency information as the alpha
 * value for the entire material */
{
    UWORD id;
    DWORD len, pc;
    WORD amount = 0;

    while((pc=dgetpos(fd)) < p) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch( (unsigned int)id ) {
          case CHUNK3DS_AMOUNT: leer_trozo_AMOUNT(&amount); break;
          default: dsetpos(pc+len, fd);
        }
    }

    (*alpha) = (FLOAT32)amount / 100.0f;
    if (*alpha < .01) (*alpha) = 1.0;
    else flag_alpha_blending = TRUE;

  #ifdef DEBUG_3DS
    printf("  - Canal Alpha (transparencia): %f\n", *alpha);
  #endif
}

void
ESCENA_3DS::leer_trozo_DOUBLESIDED(int *material_doublesided)
/*
 * I assume that if one material is doublesided, they all are,
 * so turn on a global doublesided flag
 */
{
    *material_doublesided = 1;
    flag_caras_dobles = TRUE;

  #ifdef DEBUG_3DS
    printf(" Doublesided Material\n");
  #endif
}

void
ESCENA_3DS::leer_trozo_MATNAME(DWORD /*p*/, MATERIAL_3DS *mat)
/* Reads in the name of the material */
{
    int n;
    char name[MAXNAMESIZE];
  
    n = 0;
    do {
        lea_BYTE(&name[n++], fd);
    } while( name[n-1] != '\0' && n < (int)sizeof(name) );
    name[n-1]='\0';

    strcpy(mat->name, name);

  #ifdef DEBUG_3DS
    printf("Leyendo el material \"%s\":\n", name);
  #endif
}

void
ESCENA_3DS::leer_trozo_SHADING(DWORD p, COLOR *rgb)
/* Reads in a color assignment */
{
    UWORD id;
    DWORD len, pc;

    while( (pc = dgetpos(fd)) < p ) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch( (unsigned int)id ) {
          case CHUNK3DS_RGB1: leer_trozo_RGBFloat(rgb); break;
          case CHUNK3DS_RGB2: leer_trozo_RGBByte (rgb); break;
          default: dsetpos(pc+len, fd);
        }
    }
}

void
ESCENA_3DS::leer_trozo_TRIMESH(DWORD p, char *name)
{
    UWORD id;
    WORD fl = 0; /* WG */
    DWORD len, pc;
    MESH_3DS *meshobj;
    BOOLEAN found_facemat = FALSE;

    meshobj = anx_mesh();

    strcpy(meshobj->name, name);
    while( (pc=dgetpos(fd)) < p ) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch( (int)id ) {
          case CHUNK3DS_VERTLIST: meshobj->leer_trozo_VERTLIST(); break;
          case CHUNK3DS_FACELIST: fl = meshobj->leer_trozo_FACELIST(); break;
          case CHUNK3DS_MAPLIST:  meshobj->leer_trozo_MAPLIST(); break;
          case CHUNK3DS_TRMATRIX: meshobj->leer_trozo_TRMATRIX(); break;
          case CHUNK3DS_FACEMAT:
            meshobj->leer_trozo_FACEMAT();
            found_facemat = TRUE;
            break;
       /* case CHUNK3DS_SMOOLIST: */  // IGNORADO
          default: 
          #ifdef DEBUG_3DS
            fprintf(stderr,
              "<ESCENA_3DS> - WARNING: "
                    "Ignorando un chunk desconocido (tipo %Xh, longitud %ld)\n",
              id, len);
            fflush(stderr);
            printf("  - Posicionando en %ld... (p = %ld)\t", pc+len, p); 
            fflush(stdout);
          #endif
            dsetpos(pc+len, fd);
          #ifdef DEBUG_3DS
            printf("Ok.\n\n"); fflush(stdout);
          #endif
        }
    }

    if ( !found_facemat ) {
        flag_material_por_defecto = TRUE;
        meshobj->asignar_material_por_defecto(fl); /*W.G.*/
    }
}

//===========================================================================
//= Funciones que leen trozos de nivel 2 - control de trozos de nivel 1     =
//===========================================================================

void
ESCENA_3DS::leer_trozo_MATERIAL(DWORD p)
/*
  Fills out the current material with the information contained 
  in these chunks
  */
{
    unsigned short id;
    DWORD len, pc;

    MATERIAL_3DS *materialobj = anx_material();

    while((pc=dgetpos(fd)) < p) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);

        switch((unsigned int)id) {
          case CHUNK3DS_MATNAME: 
            leer_trozo_MATNAME(pc+len, materialobj); 
            break;
          case CHUNK3DS_AMBIENT: 
            leer_trozo_SHADING(pc+len, &materialobj->ambient);
            break;
          case CHUNK3DS_DIFFUSE: 
            leer_trozo_SHADING(pc+len, &materialobj->diffuse);
            break;
          case CHUNK3DS_SPECULAR:
            leer_trozo_SHADING(pc+len, &materialobj->specular);
            break;
          case CHUNK3DS_TEXTURE:
            leer_trozo_TEXTURE(pc+len, &materialobj->texture);
            break;
          case CHUNK3DS_DOUBLESIDED:
            leer_trozo_DOUBLESIDED(&materialobj->doublesided);
            break;
          case CHUNK3DS_TRANSPARENCY:
            leer_trozo_TRANSPARENCY(pc+len, &materialobj->alpha);
            break;
          default: 
            dsetpos(pc+len, fd);
            break;
        }
    }
}

void
ESCENA_3DS::leer_trozo_OBJBLOCK(DWORD p)
{
    UWORD id;
    DWORD len, pc;
    char name[MAXNAMESIZE];

    /* The object name is always the first item */
    int n = 0;
    do {
        lea_BYTE(&name[n++], fd);
    } while( name[n-1] != '\0' && n < (int)sizeof(name) );
    name[n-1]='\0';

  #ifdef DEBUG_3DS
    printf("Read Object \"%s\"\n", name);
  #endif

    while( (pc=dgetpos(fd)) < p ) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch((int)id) {
          case CHUNK3DS_TRIMESH: 
          #ifdef DEBUG_3DS
            printf(" - Leo TRIMESH:\n");
          #endif
            leer_trozo_TRIMESH(pc+len, name);
            break;
        /*
          case CHUNK3DS_LIGHT:
          case CHUNK3DS_CAMERA:
         */
          default: dsetpos(pc+len, fd);
        }
    }

   #ifdef DEBUG_3DS
     printf("  - Listo OBJ.\n");
   #endif

    dsetpos(p, fd);
}

void
ESCENA_3DS::leer_trozo_OBJMESH(DWORD p)
{
    UWORD id;
    DWORD len, pc;

    while( (pc=dgetpos(fd)) < p ) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch( id ) {
          case CHUNK3DS_MATERIAL: 
            leer_trozo_MATERIAL(pc+len); 
            break;
          case CHUNK3DS_OBJBLOCK: 
            leer_trozo_OBJBLOCK(pc+len); 
            break;
          case CHUNK3DS_BKGCOLOR:
            //printf(
            //  "<ESCENA_3DS> OJO: Estoy ignorando un trozo BKGCOLOR (%d).\n",
            //  len);
            //fflush(stdout);
            dsetpos(pc+len, fd);
            break;
          case CHUNK3DS_AMBCOLOR:
            //printf(
            //  "<ESCENA_3DS> OJO: Estoy ignorando un trozo AMBCOLOR (%d).\n",
            //  len);
            //fflush(stdout);
            dsetpos(pc+len, fd);
            break;
          default:
            dsetpos(pc+len, fd);
            break;
        }
    }
}

//===========================================================================
//= Funciones que leen trozos de nivel 0 - control de trozos de nivel 1     =
//===========================================================================

void
ESCENA_3DS::leer_trozo_MAIN(DWORD p)
{
    UWORD id;
    DWORD len, pc;
  #ifdef DEBUG_3DS
    DWORD i;
    BYTE b;
  #endif
  
    while( (pc = dgetpos(fd) ) < p) {
        lea_WORD_BE(&id, fd);
        lea_DWORD_BE(&len, fd);
        switch( id ) {
          case CHUNK3DS_OBJMESH:
            leer_trozo_OBJMESH((DWORD)(pc+len)); 
            break;
          case CHUNK3DS_KEYFRAMER:
            dsetpos(pc+len, fd);
          #ifdef DEBUG_3DS
            fprintf(stderr,
              "<ESCENA_3DS> - WARNING: Ignorando informacion del KEYFRAMER\n");
            fflush(stderr);
          #endif
            break;
//= 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. =
          default:
          #ifdef DEBUG_3DS
            fprintf(stderr,
              "<ESCENA_3DS> - WARNING: "
                    "Ignorando un chunk desconocido (tipo %Xh, longitud %ld)\n",
              id, len);
            fflush(stderr);
            printf("El chunk ignorado contiene lo siguiente:\n");
            fflush(stdout);
            for ( i = 0; i < len; i++ ) {
                fread(&b, sizeof(BYTE), 1, fd);
                printf("%02X ", b); fflush(stdout);
                if ( i > 0 && (i%16 == 0) ) {
                    printf("\n"); fflush(stdout);
                }
            }
            printf("\n"); fflush(stdout);
            fseek(fd, -len, SEEK_CUR);
            for ( i = 0; i < len; i++ ) {
                fread(&b, sizeof(BYTE), 1, fd);
                if ( b == '\a' || b == '\n' || b == '\t' ) {
                    printf(".");
                  }
                  else {
                    printf("%c", b); fflush(stdout);
                }
                if ( i > 0 && (i%16 == 0) ) {
                    printf(" "); fflush(stdout);
                }
                if ( i > 0 && (i%64 == 0) ) {
                    printf("\n"); fflush(stdout);
                }
            }
            printf("\n\n"); fflush(stdout);
          #endif
            dsetpos(pc+len, fd);
            break;
        }
    }
}

//===========================================================================
//= CLASE ESCENA_3DS - El resto de sus metodos                              =
//===========================================================================

ESCENA_3DS::ESCENA_3DS(char *archivo) : arr_mesh(1), arr_material(1)
{
    //- init -----------------------------------------------------------------
    flag_material_por_defecto = FALSE;
    flag_alpha_blending = FALSE;
    flag_caras_dobles = FALSE;

    //- Abra y prepare el archivo de entrada ---------------------------------
    FILE *fd;

    fd = fopen(archivo, "rb");
    if( !fd ) {
        fprintf(stderr, "<ESCENA_3DS> - ERROR leyendo el archivo \"%s\"\n",
                archivo);
        fflush(stderr);
        _muerta = TRUE;
        return;
    }
    _nombre_de_archivo = new char[strlen(archivo)+1];
    ULTIMO_archivo = _nombre_de_archivo;
    strcpy(_nombre_de_archivo, archivo);

    //- Read in the file and place it in *scene -------------------------------
    if ( !leer(fd) ) {
        fprintf(stderr, "<ESCENA_3DS> Error al leer \"%s\"!\n", archivo);
        fflush(stderr);
        fclose(fd);
        _muerta = TRUE;
        return;
    }
    fclose(fd);

  #ifdef NONONO
    ADVERTIR_FALLAS();
  #endif

    _muerta = FALSE;
}

ESCENA_3DS::~ESCENA_3DS()
{
    int n,m;

    for( n = arr_mesh.tam()-1; n >= 0; n-- ) {
        MESH_3DS *mobj = &arr_mesh[n];

        if(mobj->maplist)  delete mobj->maplist;
        if(mobj->facelist) delete mobj->facelist;
        if(mobj->vertices_arr) delete mobj->vertices_arr;

        //------------------------------------------------------------
        if ( mobj->jed_arr ) {
            for ( m = 0; m < mobj->jed_tam; m++ ) {
                if ( mobj->jed_arr[m].faces ) {
                    delete mobj->jed_arr[m].faces;
                }
            }
            free(mobj->jed_arr);
        }
        //------------------------------------------------------------
    }
    arr_mesh.elim();
    arr_material.elim();
}

BOOLEAN ESCENA_3DS::muerta(void) {    return _muerta;    }

MESH_3DS *
ESCENA_3DS::anx_mesh(void)
/* Enlarge the scene array to hold a new mesh object */
{
    //-----------------------------------------------------------------------
    MESH_3DS o;

    if( !arr_mesh.anx(o) ) {
        fprintf(stderr, "<ESCENA_3DS> Error de memoria en anx_mesh.\n");
        fflush(stderr);
    }

    //-----------------------------------------------------------------------
    MESH_3DS *obj;

    obj = &arr_mesh[arr_mesh.tam()-1];
    memset(obj, 0, sizeof(MESH_3DS));
    obj->fd = fd;

    return obj;
}

MATERIAL_ARR *
MESH_3DS::anx_data(void)
/* Enlarges the bindings array to hold another bindings list */
{
    //-----------------------------------------------------------------------
/*
    MATERIAL_ARR o;

    if( !arr_jed.anx(o) ) {
        fprintf(stderr, "<ESCENA_3DS> Error de memoria en anx_data.\n");
        fflush(stderr);
    }
*/
    void *mem;
    mem = realloc(jed_arr, sizeof(MATERIAL_ARR)*(jed_tam+1));
    if( !mem ) {
        fprintf(stderr, "<ESCENA_3DS> Error de memoria en anx_data.\n");
        fflush(stderr);
    }
    jed_arr = (MATERIAL_ARR *)mem;
    jed_tam++;

    //-----------------------------------------------------------------------
    MATERIAL_ARR *obj;

    obj = &jed_arr[jed_tam-1];
    memset(obj, 0, sizeof(MATERIAL_ARR));
    
    return obj;
}

MATERIAL_3DS *
ESCENA_3DS::anx_material(void)
/* Enlarge the scene array to hold a new material */
{
    //-----------------------------------------------------------------------
    MATERIAL_3DS o;

    if( !arr_material.anx(o) ) {
        fprintf(stderr, "<ESCENA_3DS> Error de memoria en anx_material.\n");
        fflush(stderr);
    }
    //-----------------------------------------------------------------------
    MATERIAL_3DS *obj;

    obj = &arr_material[arr_material.tam()-1];
    memset(obj, 0, sizeof(MATERIAL_3DS));

    return obj;
}

BOOLEAN
ESCENA_3DS::leer(FILE *_fd)
{
    UWORD id;
    DWORD len, pc;

    fd = _fd;

    //- Verifique el encabezado del archico 3DS -----------------------------
    pc = dgetpos(fd);
    lea_WORD_BE(&id, fd);
    lea_DWORD_BE(&len, fd);
        //printf("Empiezo a leer 3DS, con longitud %X\n", len);
        //printf("El primer id CHUNK3DS_MAIN (%Xh) es %Xh\n",
        //        CHUNK3DS_MAIN, id);

    if( (WORD)id != (WORD)CHUNK3DS_MAIN ) {
        fprintf(stderr, 
                "<ESCENA_3DS> - ERROR:\n"
                "    El primer id no es CHUNK3DS_MAIN (%Xh), sino %Xh\n",
                CHUNK3DS_MAIN, id);
        fflush(stderr);
        return FALSE;
    }

    //- Lea los trozos del archivo ------------------------------------------
    leer_trozo_MAIN(pc+len); // Notese que aqui se hace todo
    return TRUE;
}

//===========================================================================
//= FUNCIONES PARA EXPORTAR DATOS DE ESTA REPRESENTACION A DATOS AQUYNZA    =
//===========================================================================

// COMENTADO
        // Apply this material's translation matrix to this material's vertices
        // This doesn't seem to work as a normal transformation matrix, so this
        // part is commented out.
        /*
        if ( meshobj->con_matriz ) {
            m = meshobj->TraMatrix;
            for ( y = 0; y < meshobj->vertices_tam; y++ ) {
                prime.x = m[0]*meshobj->vertices_arr[y].x +
                          m[3]*meshobj->vertices_arr[y].y +
                          m[6]*meshobj->vertices_arr[y].z;
                prime.y = m[1]*meshobj->vertices_arr[y].x +
                          m[4]*meshobj->vertices_arr[y].y +
                          m[7]*meshobj->vertices_arr[y].z;
                prime.z = m[2]*meshobj->vertices_arr[y].x +
                          m[5]*meshobj->vertices_arr[y].y +
                          m[8]*meshobj->vertices_arr[y].z;
                prime.x += m[9];
                prime.y += m[10];
                prime.z += m[11];
                meshobj->vertices_arr[y].x = prime.x;
                meshobj->vertices_arr[y].y = prime.y;
                meshobj->vertices_arr[y].z = prime.z;
            }
        }
        */

void
importar_3DS(ESCENA_3DS *Scene, MESH *Geometria, BOOLEAN *flag_blend,
             double *Escala_optima)
{
    int i;

    Geometria->set_nombre_de_archivo(Scene->_nombre_de_archivo);

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

    if ( Scene->flag_material_por_defecto ) {
        //- 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;
        Geometria->anx_material(ambient, diffuse, specular,
                                "WG_DEFAULT", "", 1);
      #ifdef DEBUG_3DS
        printf("<importe_3DS> OJO: Voy con el material por defecto!\n");
        fflush(stdout);
      #endif
    }

    for ( i = 0; i < Scene->arr_material.tam(); i++ ) {
        // OJO: Aquien se le pone el canal alpha?
        MATERIAL_3DS *mat = &Scene->arr_material[i];
        ambient.r = mat->ambient.r/2;
        ambient.g = mat->ambient.g/2;
        ambient.b = mat->ambient.b/2;
        ambient.alpha = 1.0;
        diffuse.r = mat->diffuse.r;
        diffuse.g = mat->diffuse.g;
        diffuse.b = mat->diffuse.b;
        //diffuse.alpha = mat->alpha;
        diffuse.alpha = 1.0;
        specular.r = mat->specular.r;
        specular.g = mat->specular.g;
        specular.b = mat->specular.b;
        specular.alpha = 1.0;
        Geometria->anx_material(ambient, diffuse, specular,
                                mat->name, mat->texture.texturename,
                                mat->doublesided);
    }

    // Esto es para calcular el factor de escala optima
    VECTOR min, max, factor;

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

    //- Exporte la geometria y la topologia de la malla ----------------------
    TRIANGULO_GL tri;
    VERTICE_GL v;
    int y;
    unsigned int z;
    int current;
    FLOAT32 swap;
    char *name;
    MATRIZ_4x4 R;
    VECTOR p;

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

    for ( current = 0, i = 0; i < Scene->arr_mesh.tam(); i++ ) {
        MESH_3DS *entidad = &Scene->arr_mesh[i];

        for ( y = 0; y < entidad->vertices_tam; y++ ) {
            // OJO: Porque toca hacer esto? [Swap y and z (.3ds wierdness)]
            swap = -entidad->vertices_arr[y].y;
            entidad->vertices_arr[y].y = entidad->vertices_arr[y].z;
            entidad->vertices_arr[y].z = swap;
        }

        // Ingrese los vertices a la malla
        for ( y = 0; y < entidad->vertices_tam; y++ ) {
            v.x = entidad->vertices_arr[y].x;
            v.y = entidad->vertices_arr[y].y;
            v.z = entidad->vertices_arr[y].z;
            if ( entidad->NumMaps ) {
                v.u = entidad->maplist[y].u;
                v.v = entidad->maplist[y].v;
            }
            else {
                v.u = v.x;
                v.v = v.y;
            }
            COMPARAR_MM();
            p.x = v.x; p.y = v.y; p.z = v.z;
            p = R*p;
            v.x = (float)p.x; v.y = (float)p.y; v.z = (float)p.z;
            v.nx = v.ny = 0;
            v.nz = 1;
            Geometria->anx_vertex(v);
        }

        factor = max - min;
        *(Escala_optima) = 5/factor.norma();

        // Ingrese los triangulos a la malla
        for ( y = 0; y < entidad->jed_tam; y++ ) {
            name = entidad->jed_arr[y].name;
            for ( z = 0; z < entidad->jed_arr[y].NumFaces; z++ ) {
                /* Flip the polygon orientation by using points (0,2,1) */
                tri.p0 =
                 entidad->facelist[entidad->jed_arr[y].faces[z]].p0 + current;
                tri.p1 =
                 entidad->facelist[entidad->jed_arr[y].faces[z]].p2 + current;
                tri.p2 =
                 entidad->facelist[entidad->jed_arr[y].faces[z]].p1 + current;
                Geometria->anx_triangle(tri, name);
            }
        }
        current += entidad->vertices_tam;
    }

    (*flag_blend) = Scene->flag_alpha_blending;

    Geometria->init();
}

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