*
model_loader.h

sert a charger des fichier de model 3D (format .ASE)
et les transforme en entité affichable sous opengl

auteur:jolrael
*/

#ifndef MODEL_LOADER_H
#define MODEL_LOADER_H
#include "sdlglutils.h"
#include <vector>
#include <string>
#include <stdio.h>
using namespace std;

namespace ml
{

    typedef struct v3d v3d;
    typedef struct face face;
    typedef struct tv3d tv3d;
    typedef struct tface tface;
    struct v3d    {double x, y, z;};
    struct face {int A,B,C;};
    struct tv3d {double x,y,z;};
    struct tface {int A,B,C;};



    class element
    {
    private:
        GLuint texture;
        char nom[20];
        vector<v3d> vertex;
        vector<face> faces;
        vector<tv3d> tvertex;
        vector<tface> tfaces;

       

        void afficherface(int i);

    public:
        element();
        int charger(FILE *fichier, int n);
        void afficher();
       
    };

    class model
    {
    private:
        vector<element> elt;
        FILE *fichier;

    public:
        model();
        model(char *nom);
        void afficher();
        void charger(char *nom);
    };


    class model_loader
    {
    public:
        static vector<model> mod;
        static void addModel(char *url);
    };


}

#endif

fichier model_loader.cpp:

#include "model_loader.h"
#include <string.h>
#include <iostream>
using namespace std;


/*
permet de charger des models 3d au format ASE
*/

ml::model::model(char *nom)
{
    charger(nom);
}

ml::model::model()
{
   
}

void ml::model::charger(char *nom)
{
    int nbre=0;
    char tmp[14];
    fichier = fopen(nom, "r");
    if (fichier==NULL) return;
    //compte le nombre d'elements
    while(fgets(tmp, 14, fichier) != NULL)
        if (!strcmp(tmp, "*GEOMOBJECT {"))
            nbre++;
    //nbre contient le nombre d'elements
    if (nbre == 0) return;

    for (int i=1; i<=nbre; i++)
    {
        element t;
        t.charger(fichier, i);
        elt.push_back(t);
    }


    fclose(fichier);
}

void ml::model::afficher()
{
    for (int i=0; i<elt.size(); i++)
        elt[i].afficher();
}


ml::element::element()
{
    texture=0;
    strcpy(nom, "aucun nom");
}

int ml::element::charger(FILE *fichier, int n)
{
    char *tex;
    char tamp[200];
    int k=0;
    char cherche[20] = "\t*MATERIAL ";
    char tmp[20];

    rewind(fichier);
   
    while(fgets(tmp, 12, fichier) != NULL)
    {
        if(!strcmp(tmp, cherche))
        {
            k=fgetc(fichier);
            if (k-48+1 == n)//si c'est le fichier de texture voulu (-48=>c->int +1)
            {
                k=n;
                break;
            }
        }
    }
    if (k!=n) return 0; //texture non trouvée
    while (strcmp(fgets(tmp, 15, fichier), "\t\t\t*MAP_AMOUNT"));
    fgets(tmp, 19, fichier);
    fgets(tamp, 200, fichier);
    tex=strchr(tamp, '\"');
    tex = (tex+1);
    tex[strlen(tex)-2] = '\0';
    //a partir d'ici tex contient le chemin exacte de la texture
    texture=loadTexture(tex);

    for(int i=1; i<=n; i++)
        while (strcmp(fgets(tmp, 14, fichier), "\t*NODE_NAME \""));
    fgets(nom, 20, fichier);
    nom[strlen(nom)-2] = '\0';
    //nom contient le nom du mesh associé

    int n_vertex=0, n_faces=0;
    while(strcmp(fgets(tmp, 19, fichier), "\t\t*MESH_NUMVERTEX "));
    fgets(tmp, 10, fichier);
    n_vertex=atoi(tmp);
    while(strcmp(fgets(tmp, 18, fichier), "\t\t*MESH_NUMFACES "));
    fgets(tmp, 10, fichier);
    n_faces=atoi(tmp);
    //n_vertex & n_faces contiennent respectivement le nombre de vertex et de faces


    //lit les vertex
    fgets(tamp, 100, fichier);
    for (int i=0; i<n_vertex; i++)
    {
        v3d vert;
        char *ch;
        fgets(tamp, 100, fichier);
        ch=strchr(tamp, 'X'); ch=strchr(ch, '\t');
        ch=ch+1;
        sscanf(ch, "%lf\t%lf\%lf", &vert.x, &vert.y, &vert.z);

        //v3d vert ={x,y,z};
        vertex.push_back(vert);   

    }
    //les vertex sont stockés

    //lit les faces
    while(strcmp(fgets(tamp, 21, fichier), "\t\t*MESH_FACE_LIST {\n"));
    for (int i=0; i<n_faces; i++)
    {
        face fc;
        char *ch, tA[5], tB[5], tC[5];
        fgets(tamp, 200, fichier);
        ch=strchr(tamp, ':');ch+=7;
        sscanf(ch, "%s %s %s %s %s",tA, tamp, tB,tamp, tC);
        fc.A=atoi(tA); fc.B=atoi(tB); fc.C=atoi(tC);
        faces.push_back(fc);
    }
    //les faces sont lues

    //lit les vertex sur les textures
    int n_tvertex;
    while(strcmp(fgets(tmp, 20, fichier), "\t\t*MESH_NUMTVERTEX "));
    fgets(tmp, 10, fichier);
    n_tvertex=atoi(tmp);
    fgets(tamp, 200, fichier);

    for (int i=0; i<n_tvertex; i++)
    {
        tv3d tvert;
        char *ch;
        fgets(tamp, 100, fichier);
        ch=strchr(tamp, 'T'); ch=strchr(ch, '\t');
        ch=ch+1;
        sscanf(ch, "%lf\t%lf\%lf", &tvert.x, &tvert.y, &tvert.z);

        tvertex.push_back(tvert);   

    }
    //chargées

    //lit les tfaces
    int n_tfaces;
    while(strcmp(fgets(tmp, 20, fichier), "\t\t*MESH_NUMTVFACES "));
    fgets(tmp, 10, fichier);
    n_tfaces=atoi(tmp);
    fgets(tamp, 200, fichier);

    for (int i=0; i<n_tfaces; i++)
    {
        tface tf;
        char *ch;
        fgets(tamp, 100, fichier);
        ch=strchr(tamp, 'C'); ch=strchr(ch, '\t');
        ch=ch+1;
        sscanf(ch, "%ld\t%ld\%ld", &tf.A, &tf.B, &tf.C);

        tfaces.push_back(tf);   

    }

    return 1;
}


void ml::element::afficher()
{
    for (int i=0; i<faces.size(); i++)
        afficherface(i);
}

void ml::element::afficherface(int i)
{
    face f = {faces[i].A, faces[i].B, faces[i].C};
    v3d v[3];
    v[0]= vertex[f.A];
    v[1]= vertex[f.B];
    v[2]= vertex[f.C];

    //a completer pour les textures
    glBegin(GL_TRIANGLES);
    glColor3ub(0,0,255); //face bleu
    glVertex3d(v[0].x, v[0].y, v[0].z);
    glVertex3d(v[1].x, v[1].y, v[1].z);
    glVertex3d(v[2].x, v[2].y, v[2].z);   
    glEnd();


}
 

using namespace ml;

int main(int argc, char *argv[])
{
    model m;
    m.charger("models/maison.ASE");
    model_loader::mod.push_back(m);
    cout <<model_loader::mod.size(); //ici pas de probleme il m'affiche 1
    ogl g;
    g.boucle_affiche();

   

    return 0;
}

void ogl::boucle_affiche()
{

    last_time = SDL_GetTicks();
    for (;;)
    {
        start_time = SDL_GetTicks();

        while(SDL_PollEvent(&event))
        {
            switch(event.type)
            {
            case SDL_QUIT:
                exit(0);
                break;
            case SDL_KEYDOWN:
                switch (event.key.keysym.sym)
                {
                case SDLK_p:
                    takeScreenshot("test.bmp");
                    break;
                }
            }
        }

        gluLookAt(200,200,200,0,0,10,0,0,1);
        current_time = SDL_GetTicks();
        elapsed_time = current_time - last_time;
        last_time = current_time;
        glMatrixMode( GL_MODELVIEW );
        glLoadIdentity( );

        //md.afficher();

        <couleur nom="rouge">cout <<model_loader::mod.size();    //le probleme se trouve ici
       //a la ligne du dessus je devrais avoir 1 (le model chargé) mais il me dit que le vecteur est vide
       </couleur>

        glFlush();
        SDL_GL_SwapBuffers();

        stop_time = SDL_GetTicks();
        if ((stop_time - last_time) < time_per_frame)
        {
            SDL_Delay(time_per_frame - (stop_time - last_time));
        }

    }
}