class MeshLoader
{
      public:
            MeshLoader(){};
            ~MeshLoader();
            float * loadMesh();
            int getvsize();
            int getpsize();
            float * getvlist();
            int * getplist();
      private:
            int vsize;
            int psize;
            float vlist[];
            int plist[];
};

#include <iostream>
#include <fstream>
#include <math.h>
#include <stdlib.h>
using namespace std;
#include "meshloader.h"
MeshLoader::~MeshLoader()
{
}

float* MeshLoader::loadMesh()
{
    int i = 0;
    int j = 0;
    vsize = 0;
    psize = 0;
    vlist[100];
    plist[100];
    char line[255];
    char tag[255];
    ifstream fin("xml.x");

    if(fin.is_open())
    {
        while(fin.getline(line, 255) != NULL)
        {
            strcpy(tag, line);
            if(strcmp("<model>", strtok(tag, " ")) == 0)
            {
            }
            strcpy(tag, line);
            if(strcmp("<vlist>", strtok(tag, " ")) == 0)
            {
                vsize = atoi(strtok(NULL, " "));
                for(i=0;i<vsize;i++)
                {
                    fin.getline(line, 255);
                    vlist[3*i+0] = (float) atof(strtok(line, " "));
                    vlist[3*i+1] = (float) atof(strtok(NULL, " "));
                    vlist[3*i+2] = (float) atof(strtok(NULL, " "));
                }
            }
            strcpy(tag, line);
            if(strcmp("<plist>", strtok(tag, " ")) == 0)
            {
                psize = (int) atoi(strtok(NULL, " "));
                for(i=0;i<psize;i++)
                {
                    fin.getline(line, 255);
                    plist[3*i+0] = (int) atoi(strtok(line, " "));
                    plist[3*i+1] = (int) atoi(strtok(NULL, " "));
                    plist[3*i+2] = (int) atoi(strtok(NULL, " "));
                }
            }
        }
    }
    cout << &plist[0] << ":";
    cout << *&plist[0] << ":";
    return 0;
}

int MeshLoader::getvsize()
{
    return vsize;
}

int MeshLoader::getpsize()
{
    return psize;
}

float * MeshLoader::getvlist()
{
    return &vlist[0];
}

int * MeshLoader::getplist()
{
    cout << &plist[0] << ":";
    cout << *&plist[0] << ":";
    return &plist[0];
}

#include <cstdlib>
#include <iostream>
#include <string>
#include <sstream>
#include <stdio.h>
#include <math.h>
#include <time.h>

using namespace std;

#include <GL/glut.h>
#include "meshloader.h"

MeshLoader myScene;
int * p;
float * v;


int main(int argc, char **argv)
{
    p = myScene.getplist();
    v = myScene.getvlist();
    cout << p << ":";
    cout << * p << ":";
            
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA);
    glutInitWindowPosition(300,100);
    glutInitWindowSize(640,320);
    glutCreateWindow("glutton");
    glutDisplayFunc(render);
    glutIdleFunc(render);
    glutReshapeFunc(reshape);
    glutMouseFunc(processMouse);
    glutMotionFunc(processMouseActiveMotion);
    glutPassiveMotionFunc(Motion);
    glutEntryFunc(processMouseEntry);
    glutKeyboardFunc(processNormalKeys);
    glutSpecialFunc(processSpecialKeys);
    glEnable(GL_DEPTH_TEST);
    glutMainLoop();
    return 0;
}