vos/3D/libASE/tase/TAseLoader.cpp

Go to the documentation of this file.

// ** TAseLoader: C++ class for reading .ase 3D file format
// ** Copyright (C) 03/08/2002 [ 23:28 x) ] Gorka Lertxundi Osa

#include "TAseLoader.h"

// **
// ** EXTERNAL FUNCTIONS
// **

// ** pow, do the power :) (sqr?)
#define sqr(x) x*x

// ** str2int | str2long | str2float ** : converting var's format.

#define str2int(string)     atoi(string)
#define str2long(string)    atol(string)
#define str2float(string)   atof(string)

// ** no_create ** : function that checks if FILE exists. ( assert() :? )

uint no_create(char *file)
{
    FILE *fp;
    fp = fopen(file,"r");
    if(fp != NULL)
    {
        // exists!
        return 1;
    }   
    else 
    {
        // don't exists!
        return 0;
    }
    fclose(fp);
}

// **
// ** INTERNAL FUNCTIONS 
// **

// <public>

uint    TAseLoader::LoadFile(char *filename)
{
    // var's
    int current_obj     = 0;
    int current_cam     = 0;
    int current_light   = 0;
    int current_shape   = 0;
    int current_vertex  = 0;
    int current_trin    = 0;
    int current_f_norm  = 0;
    int current_tvertex = 0;
    int current_tface   = 0;
    int hm_tvertex      = 0;
    int *tvertex;
    int NumOfTVertex;
    int NumOfTFaces;

    char buffer[256];
    string ss,tmp;
    ifstream ase_file;

    // us_var
    SceneInfo *info;

    // tmp.
    Vertex3D **tmp_vertex;
    Vertex3D **tmp_vertex_normal;
    Vertex3D **tmp_tvertex;
    Triangle **tmp_tfaces;
    Triangle **tmp_trin;
    
    // GetInfo
    info = ReadSceneInfo(filename);
    if(info == NULL)
        return 0;

    // Malloking :)
    ase_scene         = (Scene3D  *)malloc(sizeof(Scene3D));
    ase_scene->objs   = (Object3D *)malloc(info->ObjsNum*sizeof(Object3D));
    ase_scene->cams   = (Camera3D *)malloc(info->CamsNum*sizeof(Camera3D));
    ase_scene->lights = (Light3D *)malloc(info->LightsNum*sizeof(Light3D));
    ase_scene->shapes = (Shape3D *)malloc(info->ShapesNum*sizeof(Shape3D));

    tmp_vertex_normal = (Vertex3D **)malloc(info->ObjsNum*sizeof(Vertex3D *));
    tmp_vertex        = (Vertex3D **)malloc(info->ObjsNum*sizeof(Vertex3D *));
    tmp_tvertex       = (Vertex3D **)malloc(info->ObjsNum*sizeof(Vertex3D *));
    tmp_tfaces        = (Triangle **)malloc(info->ObjsNum*sizeof(Triangle *));
    tmp_trin          = (Triangle **)malloc(info->ObjsNum*sizeof(Triangle *));
    tvertex           = (int *)malloc(info->ObjsNum*sizeof(int));

    // number of (objs,lights,cams)
    ase_scene->NumberOfObjects = info->ObjsNum;
    ase_scene->NumberOfCameras = info->CamsNum;
    ase_scene->NumberOfLights  = info->LightsNum;
    ase_scene->NumberOfShapes  = info->ShapesNum;

    ase_file.open(filename,ios::in);
    
    while(!ase_file.eof())
    {
        ase_file.getline(buffer,256);
        ss = buffer;
        
        // Read ASciiExport version.
        if(ss.find("*COMMENT",0) != string::npos)
        {
            tmp = ss.substr(ss.find("\"",0)+1,ss.rfind("\"",ss.length())-ss.find("\"",0)-1);
            ascii_version = (char *)malloc((ss.rfind("\"",ss.length())-ss.find("\"",0)-1)*sizeof(char));
            strcpy(ascii_version,tmp.c_str());
            ascii_version[strlen(ascii_version)] = '\0';
            tmp.erase();
        }

        // Read Objects
        if(ss.find(GOBJECT,0) != string::npos && current_obj != info->ObjsNum)
        {
            // temporal variable
            bool objs_read = false;
            bool node_name = false;

            while(objs_read == false)
            {
                ase_file.getline(buffer,256);
                ss = buffer;
                // Read Object Name
                if(ss.find("*NODE_NAME",0) != string::npos && node_name == false)
                {
                    tmp = ss.substr(ss.find("\"",0)+1,ss.rfind("\"",ss.length())-ss.find("\"",0)-1);
                    ase_scene->objs[current_obj].name = (char *)malloc( (ss.rfind("\"",ss.length())-ss.find("\"",0)) * sizeof(char) );
                    strcpy(ase_scene->objs[current_obj].name,tmp.c_str());
                    ase_scene->objs[current_obj].name[strlen(ase_scene->objs[current_obj].name)] = '\0';
                    tmp.erase();
                    node_name = true;
                }
                // Read Mesh
                // ** read num of vertex
                if(ss.find(NUM_VERTEX,0) != string::npos)
                {
                    tmp = ss.substr(ss.find(NUM_VERTEX,0)+strlen(NUM_VERTEX),ss.length());
                    ase_scene->objs[current_obj].NumOfVertex = str2int(tmp.c_str());
                    tmp_vertex[current_obj]         = (Vertex3D *)malloc(ase_scene->objs[current_obj].NumOfVertex*sizeof(Vertex3D));
                    tmp_vertex_normal[current_obj]  = (Vertex3D *)malloc(ase_scene->objs[current_obj].NumOfVertex*sizeof(Vertex3D));
                }
                // ** read num of faces
                if(ss.find(NUM_FACES,0) != string::npos)
                {
                    tmp = ss.substr(ss.find(NUM_FACES,0)+strlen(NUM_FACES),ss.length());
                    ase_scene->objs[current_obj].NumOfFaces = str2int(tmp.c_str());
                    ase_scene->objs[current_obj].faces = (Face *)malloc(ase_scene->objs[current_obj].NumOfFaces*sizeof(Face));
                    tmp_trin[current_obj] = (Triangle *)malloc(ase_scene->objs[current_obj].NumOfFaces*sizeof(Triangle));
                }
                // ** read num of tvertex
                if(ss.find(NUM_TVERTEX,0) != string::npos)
                {
                    tmp = ss.substr(ss.find(NUM_TVERTEX,0)+strlen(NUM_TVERTEX),ss.length());
                    NumOfTVertex                = str2int(tmp.c_str());
                    tmp_tvertex[current_obj]    = (Vertex3D *)malloc(NumOfTVertex*sizeof(Vertex3D));                    
                }
                // ** read num of tfaces
                if(ss.find(NUM_TFACES,0) != string::npos)
                {
                    tmp = ss.substr(ss.find(NUM_TFACES,0)+strlen(NUM_TFACES),ss.length());
                    NumOfTFaces             = str2int(tmp.c_str());
                    tmp_tfaces[current_obj] = (Triangle *)malloc(NumOfTFaces*sizeof(Triangle));
                }
                // ** read vertex
                if(ss.find(VERTEX,0) != string::npos)
                {
                    while(current_vertex != ase_scene->objs[current_obj].NumOfVertex)
                    {
                        ase_file.getline(buffer,256);
                        Vertex3D vertex = ReadVertex(buffer);
                        tmp_vertex[current_obj][current_vertex].x = vertex.x;
                        tmp_vertex[current_obj][current_vertex].y = vertex.y;
                        tmp_vertex[current_obj][current_vertex].z = vertex.z;
                        current_vertex++;
                    }
                }
                // ** read faces
                if(ss.find(FACE,0) != string::npos)
                {
                    while(current_trin != ase_scene->objs[current_obj].NumOfFaces)
                    {
                        ase_file.getline(buffer,256);
                        Triangle trin = ReadTriangle(buffer);
                        tmp_trin[current_obj][current_trin].a = trin.a;
                        tmp_trin[current_obj][current_trin].b = trin.b;
                        tmp_trin[current_obj][current_trin].c = trin.c;
                        current_trin++;
                    }
                }
                // ** read tvertex
                if(ss.find(TVERTEX,0) != string::npos)
                {
                    while(current_tvertex != NumOfTVertex)
                    {
                        ase_file.getline(buffer,256);
                        Vertex3D vertex = ReadUV(buffer);
                        tmp_tvertex[current_obj][current_tvertex].x = vertex.x;
                        tmp_tvertex[current_obj][current_tvertex].y = vertex.y;
                        tmp_tvertex[current_obj][current_tvertex].z = vertex.z;
                        current_tvertex++;
                    }
                    tvertex[hm_tvertex] = current_obj;
                    hm_tvertex++;
                }               
                // ** read tfaces
                if(ss.find(TFACE,0) != string::npos)
                {
                    while(current_tface != NumOfTFaces)
                    {
                        ase_file.getline(buffer,256);
                        Triangle trin = ReadUVFaces(buffer);
                        tmp_tfaces[current_obj][current_tface].a = trin.a;
                        tmp_tfaces[current_obj][current_tface].b = trin.b;
                        tmp_tfaces[current_obj][current_tface].c = trin.c;
                        current_tface++;
                    }
                    ase_scene->objs[current_obj].tex_read = true;
                }
                // ** read vertex and face normals
                if(ss.find("*MESH_FACENORMAL",0) != string::npos)
                {
                    while(current_f_norm != ase_scene->objs[current_obj].NumOfFaces)
                    {
                        Vertex3D vertex;
                        
                        // face normal
                        vertex = ReadFaceNormal(buffer);
                        ase_scene->objs[current_obj].faces[current_f_norm].face_normal.x = vertex.x;
                        ase_scene->objs[current_obj].faces[current_f_norm].face_normal.y = vertex.y;
                        ase_scene->objs[current_obj].faces[current_f_norm].face_normal.z = vertex.z;

                        ase_file.getline(buffer,256);
                        // vertex normal 1
                        vertex = ReadVertexNormal(buffer);
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[0].x = vertex.x;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[0].y = vertex.y;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[0].z = vertex.z;
                        
                        ase_file.getline(buffer,256);
                        // vertex normal 2
                        vertex = ReadVertexNormal(buffer);
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[1].x = vertex.x;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[1].y = vertex.y;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[1].z = vertex.z;

                        ase_file.getline(buffer,256);
                        // vertex normal 3
                        vertex = ReadVertexNormal(buffer);
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[2].x = vertex.x;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[2].y = vertex.y;
                        ase_scene->objs[current_obj].faces[current_f_norm].vertex_normal[2].z = vertex.z;
                        
                        ase_file.getline(buffer,256);
                        current_f_norm++;
                    }
                    objs_read       = true;
                    normals_read  = true;
                }
                else if(ss.find("*PROP_RECVSHADOW",0) != string::npos)
                {
                    normals_read    = false;
                    objs_read       = true;
                    if(ase_scene->objs[current_obj].tex_read != true)
                        ase_scene->objs[current_obj].tex_read = false;
                }
                // ** put init values if exists more than one object
                if(current_trin == ase_scene->objs[current_obj].NumOfFaces && objs_read == true)
                {
                    current_f_norm  = 0;
                    current_trin    = 0;
                    current_vertex  = 0;
                    current_tvertex = 0;
                    current_tface   = 0;
                    current_obj++;
                }               
            }
        }
        
        // Read Cameras
        if(ss.find(COBJECT,0) != string::npos && current_cam != info->CamsNum)
        {
        // temporal variable
            int  cams_read   = 0;
            bool node_name   = false;
            bool camera_read = false;

            while(camera_read != true)
            {
                ase_file.getline(buffer,256);
                ss = buffer;

                // Read Camera Name
                if(ss.find("*NODE_NAME",0) != string::npos && node_name == false)
                {
                    tmp = ss.substr(ss.find("\"",0)+1,ss.rfind("\"",ss.length())-ss.find("\"",0)-1);
                    ase_scene->cams[current_cam].name = (char *)malloc( (ss.rfind("\"",ss.length())-ss.find("\"",0)) * sizeof(char) );
                    strcpy(ase_scene->cams[current_cam].name,tmp.c_str());
                    ase_scene->cams[current_cam].name[strlen(ase_scene->cams[current_cam].name)] = '\0';
                    tmp.erase();
                    node_name = true;
                }

                // Read Camera TM_POS -> eye.x/y/z and center.x/y/z
                if(ss.find("*TM_POS",0) != string::npos && cams_read != 2)
                {
                    Vertex3D vertex = ReadTmPos(buffer);
                    
                    if(cams_read == 1) // if it is the second one
                    {
                        ase_scene->cams[current_cam].center.x = vertex.x;
                        ase_scene->cams[current_cam].center.y = vertex.y;
                        ase_scene->cams[current_cam].center.z = vertex.z;
                        cams_read++;
                    }
                    
                    if(cams_read == 0) // if it is the first one
                    {
                        ase_scene->cams[current_cam].eye.x = vertex.x;
                        ase_scene->cams[current_cam].eye.y = vertex.y;
                        ase_scene->cams[current_cam].eye.z = vertex.z;
                        cams_read++;
                    }
                }

                if(ss.find("*CAMERA_NEAR",0) != string::npos)
                {
                    float _Near = ReadCameraNear(buffer);
                    ase_scene->cams[current_cam].Near = _Near;
                }

                if(ss.find("*CAMERA_FAR",0) != string::npos)
                {
                    float _Far = ReadCameraFar(buffer);
                    ase_scene->cams[current_cam].Far = _Far;
                }

                if(ss.find("*CAMERA_FOV",0) != string::npos)
                {
                    float fov = ReadCameraFov(buffer);
                    ase_scene->cams[current_cam].fov = fov;
                    cams_read = 3;
                }

                if(cams_read == 3)
                {
                    camera_read = true;
                    node_name   = false;
                    current_cam++;
                }
            }
            cams_read = 0;
        }


        // Read Lights
        if(ss.find(LOBJECT,0) != string::npos && current_light != info->LightsNum)
        {
            int  pos_count  = 0;
            bool light_read = false;
            bool node_name  = false;
            while(light_read != true)
            {
                ase_file.getline(buffer,256);
                ss = buffer;

                // Read Light Name
                if(ss.find("*NODE_NAME",0) != string::npos && node_name == false)
                {
                    tmp = ss.substr(ss.find("\"",0)+1,ss.rfind("\"",ss.length())-ss.find("\"",0)-1);
                    ase_scene->lights[current_light].name = (char *)malloc( (ss.rfind("\"",ss.length())-ss.find("\"",0)) * sizeof(char) );
                    strcpy(ase_scene->lights[current_light].name,tmp.c_str());
                    ase_scene->lights[current_light].name[strlen(ase_scene->lights[current_light].name)] = '\0';
                    tmp.erase();
                    node_name = true;
                }

                if(ss.find("*LIGHT_TYPE",0) != string::npos)
                {
                    ase_scene->lights[current_light].type = ReadLightType(buffer);
                }

                if(ss.find("*TM_POS",0) != string::npos)
                {
                    if(ase_scene->lights[current_light].type == SPOT)
                    {
                        if(pos_count == 0)
                        {
                            Vertex3D vertex;
                            vertex = ReadTmPos(buffer);
                            ase_scene->lights[current_light].eye.x = vertex.x;
                            ase_scene->lights[current_light].eye.y = vertex.y;
                            ase_scene->lights[current_light].eye.z = vertex.z;
                        }

                        if(pos_count == 1)
                        {
                            Vertex3D vertex;
                            vertex = ReadTmPos(buffer);
                            ase_scene->lights[current_light].center.x = vertex.x;
                            ase_scene->lights[current_light].center.y = vertex.y;
                            ase_scene->lights[current_light].center.z = vertex.z;
                        }
                        pos_count++;
                    }
                    if(ase_scene->lights[current_light].type == OMNI)
                    {
                        Vertex3D vertex;
                        vertex = ReadTmPos(buffer);
                        ase_scene->lights[current_light].eye.x = vertex.x;
                        ase_scene->lights[current_light].eye.y = vertex.y;
                        ase_scene->lights[current_light].eye.z = vertex.z;
                        pos_count = 2;
                    }
                }

                if(ss.find("*LIGHT_COLOR",0) != string::npos)
                {
                    ColorRGB color = ReadLightColor(buffer);
                    ase_scene->lights[current_light].color.r = color.r;
                    ase_scene->lights[current_light].color.g = color.g;
                    ase_scene->lights[current_light].color.b = color.b;
                    
                    if(ase_scene->lights[current_light].type == OMNI)
                        pos_count = 3;
                }

                if(ss.find("*LIGHT_FALLOFF",0) != string::npos)
                {
                    float falloff = ReadLightFallOff(buffer);
                    ase_scene->lights[current_light].falloff = falloff;

                    pos_count = 3;
                }
                
                if(pos_count == 3)
                    light_read = true;
            }
            current_light++;
        }
        
        // Read Shapes...
        if(ss.find("*SHAPEOBJECT",0) != string::npos && current_shape != info->ShapesNum)
        {
            bool shape_read = false;
            bool node_name  = false;
            while(shape_read != true)
            {
                ase_file.getline(buffer,256);
                ss = buffer;

                if(ss.find("*NODE_NAME",0) != string::npos && node_name == false)
                {
                    tmp = ss.substr(ss.find("\"",0)+1,ss.rfind("\"",ss.length())-ss.find("\"",0)-1);
                    ase_scene->shapes[current_shape].name = (char *)malloc( (ss.rfind("\"",ss.length())-ss.find("\"",0)) * sizeof(char) );
                    strcpy(ase_scene->shapes[current_shape].name,tmp.c_str());
                    ase_scene->shapes[current_shape].name[strlen(ase_scene->shapes[current_shape].name)] = '\0';
                    tmp.erase();
                    node_name = true;
                }

                if(ss.find("*SHAPE_VERTEXCOUNT",0) != string::npos)
                {
                    int shape_vnum  = ReadShapeVertexCount(buffer);
                    int counter     = 0;
                    int knot_c      = 0;
                    int seek_pos    = ase_file.tellg();
                    
                    ase_scene->shapes[current_shape].NumOfKnot = 0;

                    while(counter < shape_vnum) // < numero de vertex
                    {
                        ase_file.getline(buffer,256);
                        ss = buffer;
                        if(ss.find("*SHAPE_VERTEX_KNOT",0) != string::npos)
                        {
                            ase_scene->shapes[current_shape].NumOfKnot++;
                        }
                        counter++;
                    }

                    ase_scene->shapes[current_shape].knot = (Vertex3D *)malloc( ase_scene->shapes[current_shape].NumOfKnot * sizeof(Vertex3D));

                    ase_file.seekg(seek_pos);
                    counter = 0;
                    while(counter < shape_vnum) // < numero de vertex
                    {
                        ase_file.getline(buffer,256);
                        ss = buffer;
                        if(ss.find("*SHAPE_VERTEX_KNOT",0) != string::npos)
                        {
                            Vertex3D vertex;
                            vertex = ReadShapeKNOT(buffer);
                            ase_scene->shapes[current_shape].knot[knot_c].x = vertex.x;
                            ase_scene->shapes[current_shape].knot[knot_c].y = vertex.y;
                            ase_scene->shapes[current_shape].knot[knot_c].z = vertex.z;
                            knot_c++;
                        }
                        counter++;
                    }
                    shape_read = true;
                }
            }
            current_shape++;
        }

    }
    // end reading...

    // Cloooooooosing the file... :)
    ase_file.close();

    // Put all read data in Scene3D var.
    for(current_obj = 0; current_obj < ase_scene->NumberOfObjects ; current_obj++)
    {
        for(int x = 0; x < ase_scene->objs[current_obj].NumOfFaces ; x++)
        {
            // vertex one
            ase_scene->objs[current_obj].faces[x].vertex[0].x = tmp_vertex[current_obj][tmp_trin[current_obj][x].a].x;
            ase_scene->objs[current_obj].faces[x].vertex[0].y = tmp_vertex[current_obj][tmp_trin[current_obj][x].a].y;
            ase_scene->objs[current_obj].faces[x].vertex[0].z = tmp_vertex[current_obj][tmp_trin[current_obj][x].a].z;

            // vertex two
            ase_scene->objs[current_obj].faces[x].vertex[1].x = tmp_vertex[current_obj][tmp_trin[current_obj][x].b].x;
            ase_scene->objs[current_obj].faces[x].vertex[1].y = tmp_vertex[current_obj][tmp_trin[current_obj][x].b].y;
            ase_scene->objs[current_obj].faces[x].vertex[1].z = tmp_vertex[current_obj][tmp_trin[current_obj][x].b].z;

            // vertex three
            ase_scene->objs[current_obj].faces[x].vertex[2].x = tmp_vertex[current_obj][tmp_trin[current_obj][x].c].x;
            ase_scene->objs[current_obj].faces[x].vertex[2].y = tmp_vertex[current_obj][tmp_trin[current_obj][x].c].y;
            ase_scene->objs[current_obj].faces[x].vertex[2].z = tmp_vertex[current_obj][tmp_trin[current_obj][x].c].z;

            if(ase_scene->objs[current_obj].tex_read == true)
            {
                // tex_coord vertex one
                ase_scene->objs[current_obj].faces[x].tex_coords[0].u = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].a].x;
                ase_scene->objs[current_obj].faces[x].tex_coords[0].v = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].a].y;
                
                // tex_coord vertex two
                ase_scene->objs[current_obj].faces[x].tex_coords[1].u = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].b].x;
                ase_scene->objs[current_obj].faces[x].tex_coords[1].v = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].b].y;
    
                // tex_coord vertex three
                ase_scene->objs[current_obj].faces[x].tex_coords[2].u = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].c].x;
                ase_scene->objs[current_obj].faces[x].tex_coords[2].v = tmp_tvertex[current_obj][tmp_tfaces[current_obj][x].c].y;
            }   
        }
    }

    // free all tmp var's (3D scenes [vertex,faces,normal,tex_coords] 
    for(int x = 0; x < info->ObjsNum ; x++)
    {
        free(tmp_vertex[x]);
        free(tmp_trin[x]);
        free(tmp_vertex_normal[x]);
    }
    for(int y = 0; y < hm_tvertex ; y++)
    {
        free(tmp_tvertex[tvertex[y]]);
        free(tmp_tfaces[tvertex[y]]);
    }
    free(tmp_vertex);
    free(tmp_tvertex);
    free(tmp_tfaces);
    free(tmp_trin);
    free(tmp_vertex_normal);
    free(info);
    return 1;
}

// <protected>

Vertex3D TAseLoader::ReadVertex(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find("*MESH_VERTEX"))+1,ss.length());
    // 3DStudioMax azix = XZY we want... XY(-Z)
    vertex.x = str2float(floats.substr(0,floats.find("\t")).c_str());
    vertex.z = -1*str2float(floats.substr(floats.find("\t"),floats.rfind("\t",floats.length())).c_str());
    vertex.y = str2float(floats.substr(floats.rfind("\t",floats.length()),floats.length()).c_str());
    return vertex;
}

// <protected>

Triangle TAseLoader::ReadTriangle(char *lstring)
{
    Triangle trin;
    string ss;
    ss = lstring;
    trin.a = str2int(ss.substr(ss.find("A:")+2,ss.find("B:",0)-ss.find("A:",0)-2).c_str());
    trin.b = str2int(ss.substr(ss.find("B:")+2,ss.find("C:",0)-ss.find("B:",0)-2).c_str());
    trin.c = str2int(ss.substr(ss.find("C:")+2,ss.find("AB:",0)-ss.find("C:",0)-2).c_str());
    return trin;
}

// <protected>

Vertex3D TAseLoader::ReadVertexNormal(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find("*MESH_VERTEXNORMAL"))+1,ss.length());
    // 3DStudioMax azix = XZY we want... XY(-Z)
    vertex.x = str2float(floats.substr(0,floats.find("\t",0)).c_str());
    vertex.z = -1*str2float(floats.substr(floats.find("\t")+1,floats.rfind("\t",floats.length())-floats.find("\t")).c_str());
    vertex.y = str2float(floats.substr(floats.rfind("\t",floats.length())+1,ss.length()).c_str());
    return vertex;
}

// <protected>

Vertex3D TAseLoader::ReadUV(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find(TVERTEX))+1,ss.length());
    vertex.x = str2float(floats.substr(0,floats.find("\t")).c_str());
    vertex.y = str2float(floats.substr(floats.find("\t"),floats.rfind("\t",floats.length())).c_str());
    vertex.z = str2float(floats.substr(floats.rfind("\t",floats.length()),floats.length()).c_str());
    return vertex;
}

// <protected>

Triangle TAseLoader::ReadUVFaces(char *lstring)
{
    Triangle tri;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find(TFACE))+1,ss.length());
    tri.a = str2int(floats.substr(0,floats.find("\t")).c_str());
    tri.b = str2int(floats.substr(floats.find("\t"),floats.rfind("\t",floats.length())).c_str());
    tri.c = str2int(floats.substr(floats.rfind("\t",floats.length()),floats.length()).c_str());
    return tri;
}

// <protected>

Vertex3D TAseLoader::ReadFaceNormal(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find("*MESH_FACENORMAL"))+1,ss.length());
    // 3DStudioMax azix = XZY we want... XY(-Z)
    vertex.x = str2float(floats.substr(0,floats.find("\t",0)).c_str());
    vertex.z = -1*str2float(floats.substr(floats.find("\t")+1,floats.rfind("\t",floats.length())-1-floats.find("\t")).c_str());
    vertex.y = str2float(floats.substr(floats.rfind("\t",floats.length())+1,ss.length()).c_str());
    return vertex;
}

// <protected>

Vertex3D TAseLoader::ReadTmPos(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("*TM_POS")+strlen("*TM_POS"),ss.length());
    // 3DStudioMax azix = XZY we want... XY(-Z)
    vertex.x = str2float(floats.substr(0,floats.find("\t",0)).c_str());
    vertex.z = -1*str2float(floats.substr(floats.find("\t")+1,floats.rfind("\t",floats.length())-1-floats.find("\t")).c_str());
    vertex.y = str2float(floats.substr(floats.rfind("\t",floats.length())+1,ss.length()).c_str());
    return vertex;
}

// <protected>

int TAseLoader::ReadLightType(char *lstring)
{
    string ss;
    ss = lstring;
    if(strcmp(ss.substr(ss.find("*LIGHT_TYPE",0)+1+strlen("*LIGHT_TYPE"),ss.length()).c_str(),"Target") == 0)
        return SPOT;
    else
        return OMNI;
}
    
ColorRGB TAseLoader::ReadLightColor(char *lstring)
{
    ColorRGB color;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("*LIGHT_COLOR",0)+strlen("*LIGHT_COLOR")+1,ss.length()).c_str();
    color.r = str2float(floats.substr(0,floats.find("\t",0)).c_str());
    color.g = str2float(floats.substr(floats.find("\t")+1,floats.rfind("\t",floats.length())-1-floats.find("\t")).c_str());
    color.b = str2float(floats.substr(floats.rfind("\t",floats.length())+1,ss.length()).c_str());
    return color;
}

float TAseLoader::ReadLightFallOff(char *lstring)
{
    float falloff;
    string ss;
    ss = lstring;
    falloff = str2float(ss.substr(ss.find("*LIGHT_FALLOFF",0)+strlen("*LIGHT_FALLOFF")+1,ss.length()).c_str());
    return falloff;
}

float TAseLoader::ReadCameraFov(char *lstring)
{
    float fov;
    string ss;
    ss = lstring;
    fov = str2float(ss.substr(ss.find("*CAMERA_FOV",0)+strlen("*CAMERA_FOV")+1,ss.length()).c_str());
    return fov;
}

float TAseLoader::ReadCameraNear(char *lstring)
{
    float Near;
    string ss;
    ss = lstring;
    Near = str2float(ss.substr(ss.find("*CAMERA_NEAR",0)+strlen("*CAMERA_NEAR")+1,ss.length()).c_str());
    return Near;
}

float TAseLoader::ReadCameraFar(char *lstring)
{
    float Far;
    string ss;
    ss = lstring;
    Far = str2float(ss.substr(ss.find("*CAMERA_FAR",0)+strlen("*CAMERA_FAR")+1,ss.length()).c_str());
    return Far;
}

uint TAseLoader::ReadShapeVertexCount(char *lstring)
{
    string ss;
    ss = lstring;
    return str2int(ss.substr(ss.find("*SHAPE_VERTEXCOUNT",0)+strlen("*SHAPE_VERTEXCOUNT"),ss.length()).c_str());
}

Vertex3D TAseLoader::ReadShapeKNOT(char *lstring)
{
    Vertex3D vertex;
    string ss,floats;
    ss = lstring;
    floats = ss.substr(ss.find("\t",ss.find("*SHAPE_VERTEX_KNOT")+strlen("*SHAPE_VERTEX_KNOT")+1)+1,ss.length());
    // 3DStudioMax azix = XZY we want... XY(-Z)
    vertex.x = str2float(floats.substr(0,floats.find("\t")).c_str());
    vertex.z = -1*str2float(floats.substr(floats.find("\t"),floats.rfind("\t",floats.length())).c_str());
    vertex.y = str2float(floats.substr(floats.rfind("\t",floats.length()),floats.length()).c_str());
    return vertex;
}

// <protected>

SceneInfo* TAseLoader::ReadSceneInfo(char *filename)
{
    char buffer[256];
    string ss,tmp;
    ifstream ase_file;

    // SceneInfo
    SceneInfo *info;

    if (no_create(filename) == 0)
    {
        cout << "Couldn't find or open file: " << filename << endl;
        return NULL;
    }
    
    info = (SceneInfo *)malloc(sizeof(SceneInfo));
    
    info->ObjsNum   = 0;
    info->CamsNum   = 0;
    info->LightsNum = 0;
    info->ShapesNum = 0;

    ase_file.open(filename,ios::in);

    ase_file.getline(buffer,256);
    ss = buffer;

    if(ss.find(ASEHEADER,0) == string::npos)
    {
        cout << "The file " << filename << " isn't ASciiExport(2.0) file format" << endl;
        return NULL;
    }
    
    while(!ase_file.eof())
    {
        ase_file.getline(buffer,256);
        ss = buffer;
        if(ss.find(GOBJECT,0) != string::npos)
            info->ObjsNum++;
        if(ss.find(COBJECT,0) != string::npos)
            info->CamsNum++;
        if(ss.find(LOBJECT,0) != string::npos)
            info->LightsNum++;
        if(ss.find("*SHAPEOBJECT") != string::npos)
            info->ShapesNum++;
    }

    return info;
}

// <public>

void TAseLoader::DumpInfoToFile(char *file)
{
    ofstream out_file;
    out_file.open(file,ios::out);

    out_file << "####################\n";
    out_file << "# TAseLoader::v0.1 #\n";
    out_file << "####################\n\n";
    out_file << "Scene general data:\n";
    out_file << "OBJECTS [" << setw(3) << setfill('.') << ase_scene->NumberOfObjects << "]\n";
    out_file << "CAMERAS [" << setw(3) << setfill('.') << ase_scene->NumberOfCameras << "]\n";
    out_file << "LIGHTS  [" << setw(3) << setfill('.') << ase_scene->NumberOfLights  << "]\n";
    out_file << "SHAPES  [" << setw(3) << setfill('.') << ase_scene->NumberOfShapes  << "]\n";
    
    out_file << "\n";

    if(ase_scene->NumberOfObjects != 0)
    {
        out_file << "Dumping Objects data :¨¨):\n\n"; 
        for(int current_obj = 0; current_obj < ase_scene->NumberOfObjects ; current_obj++)
        {
            out_file << setw(strlen(ase_scene->objs[current_obj].name)+5) << setfill('*') << "\n";
            out_file << "* " << ase_scene->objs[current_obj].name << " *\n";
            out_file << setw(strlen(ase_scene->objs[current_obj].name)+5) << setfill('*') << "\n";
            out_file << "\n";
    
            for(int x = 0; x < ase_scene->objs[current_obj].NumOfFaces; x++)
            {
                out_file << "FACE [" << setw(6) << setfill('.') << x << "]\n";
                
                out_file << "fn[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].face_normal.x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].face_normal.y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].face_normal.z;
                
                out_file << "\n";
                
                out_file << "n1[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[0].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[0].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[0].z;
    
                out_file << "\n";
     
                if(ase_scene->objs[current_obj].tex_read == true)
                {
                    out_file << "t1[U]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[0].u;
                    out_file << " [V]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[0].v;
        
                    out_file << "\n";
                }
    
                out_file << "v1[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[0].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[0].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[0].z;
                
                out_file << "\n";
    
                out_file << "n2[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[1].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[1].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[1].z;
    
                out_file << "\n";

                if(ase_scene->objs[current_obj].tex_read == true)
                {
                    out_file << "t2[U]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[1].u;
                    out_file << " [V]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[1].v;
        
                    out_file << "\n";
                }
    
                out_file << "v2[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[1].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[1].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[1].z;
    
                out_file << "\n";

                out_file << "n3[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[2].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[2].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex_normal[2].z;

                out_file << "\n";
    
                if(ase_scene->objs[current_obj].tex_read == true)
                {
                    out_file << "t3[U]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[2].u;
                    out_file << " [V]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].tex_coords[2].v;
        
                    out_file << "\n";
                }
    
                out_file << "v3[X]: "  << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[2].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[2].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->objs[current_obj].faces[x].vertex[2].z;
    
                out_file << "\n\n";
            }
        }
    }

    if(ase_scene->NumberOfCameras != 0)
    {
        out_file << "Dumping Cameras data :¨¨):\n\n";
        
        for(int current_cam = 0; current_cam < ase_scene->NumberOfCameras ; current_cam++)
        {
            out_file << setw(strlen(ase_scene->cams[current_cam].name)+5) << setfill('*') << "\n";
            out_file << "* " << ase_scene->cams[current_cam].name << " *\n";
            out_file << setw(strlen(ase_scene->cams[current_cam].name)+5) << setfill('*') << "\n";

            out_file << "EYE [CAMERA POSITION]" << "\n";
                out_file << " [X]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].eye.x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].eye.y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].eye.z;

            out_file << "\n";

            out_file << "CENTER [CAMERAS POINT OF VIEW]" << "\n";
                out_file << " [X]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].center.x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].center.y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->cams[current_cam].center.z;
            out_file << "\n\n";
        }
    }

    if(ase_scene->NumberOfLights != 0)
    {
        out_file << "Dumping Lights data :¨¨):\n\n";
        
        for(int current_light = 0; current_light < ase_scene->NumberOfLights ; current_light++)
        {
            out_file << setw(strlen(ase_scene->lights[current_light].name)+5) << setfill('*') << "\n";
            out_file << "* " << ase_scene->lights[current_light].name << " *\n";
            out_file << setw(strlen(ase_scene->lights[current_light].name)+5) << setfill('*') << "\n";
            
            if(ase_scene->lights[current_light].type == SPOT)
                out_file << "LIGHT TYPE: spot" << "\n"; 
            if(ase_scene->lights[current_light].type == OMNI)
                out_file << "LIGHT TYPE: omni" << "\n";
            
            out_file << "EYE [LIGHT POSITION]" << "\n";
                out_file << " [X]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].eye.x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].eye.y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].eye.z;
            
            out_file << "\n";
        
            if(ase_scene->lights[current_light].type == SPOT)
            {
                out_file << "CENTER [LIGHT ILUMINATION POINT]" << "\n";
                    out_file << " [X]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].center.x;
                    out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].center.y;
                    out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->lights[current_light].center.z;
                out_file << "\n\n";
            }
        }
    }

    if(ase_scene->NumberOfShapes != 0)
    {
        out_file << "Dumping Shapes data :¨¨):\n\n";
        
        for(int current_shape = 0; current_shape < ase_scene->NumberOfShapes ; current_shape++)
        {
            out_file << setw(strlen(ase_scene->shapes[current_shape].name)+5) << setfill('*') << "\n";
            out_file << "* " << ase_scene->shapes[current_shape].name << " *\n";
            out_file << setw(strlen(ase_scene->shapes[current_shape].name)+5) << setfill('*') << "\n";
            
            for(int knot_num = 0 ; knot_num < ase_scene->shapes[current_shape].NumOfKnot ; knot_num++)
            {
                out_file << "\nKNOT " << knot_num << "\n";
                out_file << " [X]: "   << setw(15) << setfill(' ') << ase_scene->shapes[current_shape].knot[knot_num].x;
                out_file << " [Y]: "   << setw(15) << setfill(' ') << ase_scene->shapes[current_shape].knot[knot_num].y;
                out_file << " [Z]: "   << setw(15) << setfill(' ') << ase_scene->shapes[current_shape].knot[knot_num].z;
            }
            out_file << "\n";
        }
    }
    
    out_file.close();
}


// <public> [...]

Scene3D* TAseLoader::GetScene(void)
{
    return ase_scene;
}

Object3D* TAseLoader::GetObject(int obj_num)
{
    if(ase_scene->NumberOfObjects >= obj_num)
        return &ase_scene->objs[obj_num];
    else
        return NULL;
}

Camera3D* TAseLoader::GetCamera(int cam_num)
{
    if(ase_scene->NumberOfCameras >= cam_num)
        return &ase_scene->cams[cam_num];
    else
        return NULL;
}

Light3D* TAseLoader::GetLight(int light_num)
{
    if(ase_scene->NumberOfLights >= light_num)
        return &ase_scene->lights[light_num];
    else
        return NULL;
}

Shape3D* TAseLoader::GetShape(int shape_num)
{
    if(ase_scene->NumberOfShapes >= shape_num)
        return &ase_scene->shapes[shape_num];
    else
        return NULL;
}

uint TAseLoader::GetObjectsNum(void)
{
    return ase_scene->NumberOfObjects;
}

uint TAseLoader::GetCamerasNum(void)
{
    return ase_scene->NumberOfCameras;
}

uint TAseLoader::GetLightsNum(void)
{
    return ase_scene->NumberOfLights;
}

char* TAseLoader::GetAsciiVersion(void)
{
    return ascii_version;
}

---