I cant see the textures of an exported object with Deep Exploration

Hi,

i got to show a .3ds in my opengl space just exporting it as a .cpp file with Deep Exploration.

My problem now is i cant show the textures.

Here you have the code:

#include "stdafx.h"
#include "glut.h"
#include <math.h>
#include <windows.h>


#include <iostream>
using namespace std;

GLint oo=0;
double m=5;
double n=6;
double o=10;
double b=m/n;
double c=2*b;
double f=3*b;
int i=0;
double p=2;
double q=12;
double d1=(m*sqrt(p))/q;


double array[12][3]={   0,   0,       0, //posicion 0
0,   0,       0, //1
0,   0,       b, //2
        0,   0,       c, //3
    0,   0,       c, //4
      -d1,   0,    c+d1, //5
-2*d1,   0,  c+d1*2, //6
        -2*d1,   0,  c+d1*2, //7 -> THIS IS THE STEP I CANT UNDERSTAND
  -d1,   0,  c+d1*3, //8
0,   0,  c+d1*4, //9
                       0,   0,  c+d1*4, //10
0,   0,  f+d1*4}; //11



float xpos = 0, ypos = 0, zpos = 0, xrot = 0, yrot = 0, angle=0.0;


double array2[12]={    0,  //posicion inicial
0,   //1
0,
0,
  -45,   //4
  -45,
  -45,
   45,   //7 -> THIS IS THE STEP I CANT NOT UNDERSTAND
   45,   //8
   45,
0,
0,   //11
};


//////HERE STARTS THE CODE OF THE MODEL (A CUBE)//////

struct sample_MATERIAL{
 GLfloat ambient[3];
 GLfloat diffuse[3];
 GLfloat specular[3];
 GLfloat emission[3];
 GLfloat alpha;
 GLfloat phExp;
 int   texture;
};

static sample_MATERIAL materials [1] = {
 {{0.588235f,0.588235f,0.588235f},	{0.588235f,0.588235f,0.588235f},	{0.0f,0.0f,0.0f},	{0.0f,0.0f,0.0f},	1.0f,4.0f,-1} //01 - Default
};

// 8 Verticies
// 4 Texture Coordinates
// 6 Normals
// 12 Triangles

static BYTE face_indicies[12][9] = {
// Box01
	{0,2,3 ,0,0,0 ,0,1,2 }, {3,1,0 ,0,0,0 ,2,3,0 }, {4,5,7 ,1,1,1 ,3,0,1 },
	{7,6,4 ,1,1,1 ,1,2,3 }, {0,1,5 ,2,2,2 ,3,0,1 }, {5,4,0 ,2,2,2 ,1,2,3 },
	{1,3,7 ,3,3,3 ,3,0,1 }, {7,5,1 ,3,3,3 ,1,2,3 }, {3,2,6 ,4,4,4 ,3,0,1 },
	{6,7,3 ,4,4,4 ,1,2,3 }, {2,0,4 ,5,5,5 ,3,0,1 }, {4,6,2 ,5,5,5 ,1,2,3 }
};
static GLfloat vertices [8][3] = {
{-0.5f,-0.5f,-0.5f},{0.5f,-0.5f,-0.5f},{-0.5f,0.5f,-0.5f},
{0.5f,0.5f,-0.5f},{-0.5f,-0.5f,0.5f},{0.5f,-0.5f,0.5f},
{-0.5f,0.5f,0.5f},{0.5f,0.5f,0.5f}
};
static GLfloat normals [6][3] = {
{0.0f,0.0f,-1.0f},{0.0f,0.0f,1.0f},{0.0f,-1.0f,0.0f},
{1.0f,0.0f,0.0f},{0.0f,1.0f,0.0f},{-1.0f,0.0f,0.0f}
};
static GLfloat textures [4][2] = {
{1.0f,0.0f},{1.0f,1.0f},{0.0f,1.0f},
{0.0f,0.0f}
};
/*Material indicies*/
/*{material index,face count}*/
static int material_ref [1][2] = {
{0,12}
};
void MyMaterial(GLenum mode,GLfloat *f,GLfloat alpha)
{
 GLfloat d[4];
 d[0]=f[0];
 d[1]=f[1];
 d[2]=f[2];
 d[3]=alpha;
 glMaterialfv (GL_FRONT_AND_BACK,mode,d);
}
/*
 *  SelectMaterial uses OpenGL commands to define facet colors.
 *
 *  Returns:
 *    Nothing
 */

void SelectMaterial(int i)
{
  //
  // Define the reflective properties of the 3D Object faces.
  //
  glEnd();
  GLfloat alpha=materials[i].alpha;
  MyMaterial (GL_AMBIENT, materials[i].ambient,alpha);
  MyMaterial (GL_DIFFUSE, materials[i].diffuse,alpha);
  MyMaterial (GL_SPECULAR, materials[i].specular,alpha);
  MyMaterial (GL_EMISSION, materials[i].emission,alpha);
  glMaterialf (GL_FRONT_AND_BACK,GL_SHININESS,materials[i].phExp);
  glBegin(GL_TRIANGLES);

};

GLint Gen3DObjectList()
{
 int i;
 int j;

 GLint lid=glGenLists(1);
	int mcount=0;
	int mindex=0;
   glNewList(lid, GL_COMPILE);

    glBegin (GL_TRIANGLES);
      for(i=0;i<sizeof(face_indicies)/sizeof(face_indicies[0]);i++)
       {
      if(!mcount)
       {
        SelectMaterial(material_ref[mindex][0]);
        mcount=material_ref[mindex][1];
        mindex++;
       }
       mcount--;
       for(j=0;j<3;j++)
        {
          int vi=face_indicies[i][j];
          int ni=face_indicies[i][j+3];//Normal index
          int ti=face_indicies[i][j+6];//Texture index
           glNormal3f (normals[ni][0],normals[ni][1],normals[ni][2]);
           glTexCoord2f(textures[ti][0],textures[ti][1]);
           glVertex3f (vertices[vi][0],vertices[vi][1],vertices[vi][2]);
        }
       }
    glEnd ();

   glEndList();
   return lid;
};

//////HERE FINISH THE CODE OF THE MODEL (A CUBE)//////

void init (void) {

	//nemesisgeek 03-13-07
	//Create the display list
	oo=Gen3DObjectList();

}

void enable (void) {
glEnable (GL_DEPTH_TEST); //enable the depth testing
glEnable (GL_LIGHTING); //enable the lighting
glEnable (GL_LIGHT0); //enable LIGHT0, our Diffuse Light
glShadeModel (GL_SMOOTH); //set the shader to smooth shader
}

void camera (void)
{
	//nemesisgeek 03-13-07
	//Hard-coded position for testing
	glTranslated(0,0,-5);

	/*

glTranslated(-array[i][0],-array[i][1],-array[i][2]);

glRotatef(array2[i], 0.0, 1.0, 0.0);


//translate the screen to the position of our camera
glRotatef(xrot,1.0,0.0,0.0);  //rotate our camera on teh x-axis (left and right)
glRotatef(yrot,0.0,1.0,0.0);  //rotate our camera on the y-axis (up and down)
//glRotatef(zrot,0.0,0.0,1.0);  //rotate our camera on the y-axis (up and down)

glTranslated(-xpos,-ypos,-zpos); //translate the screen to the position of our camera*/
}

void display (void)
{

	//nemesisgeek 03-13-07
	glClearColor (0.0,1.0,0.0,0.0); //clear the screen to black
	//Your original code clears the screen to WHITE, not black
	//glClearColor (1.0,1.0,1.0,1.0);

   glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); //clear the color buffer and the depth buffer
   glLoadIdentity();

   //nemesisgeek 03-13-07
   //Using gluLookAt() and glTranslate() / glRotate() is redundant
   //You can use either one but not both
   //gluLookAt (0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 1.0, 0.0); //camera position, x,y,z, looking at x,y,z, Up Positions of the camera

   camera();
   enable();

glPolygonMode(GL_FRONT_AND_BACK, GL_LINE);

//nemesisgeek 03-13-07
//Your code original code just creates the display list, it does not call it
//oo=Gen3DObjectList();
glCallList(oo);

/*glBegin(GL_QUADS);           // Draw The Cube Using quads
glColor3f(0.0f,1.0f,0.0f);     // Color Blue
glVertex3f( 2.5f, 2.5f, 0.0f);    // Top Right Of The Quad (Top)
glVertex3f(-2.5f, 2.5f, 0.0f);    // Top Left Of The Quad (Top)
glVertex3f(-2.5f, 2.5f, 5.0f);    // Bottom Left Of The Quad (Top)
glVertex3f( 2.5f, 2.5f, 5.0f);    // Bottom Right Of The Quad (Top)

glColor3f(1.0f,0.5f,0.0f);     // Color Orange
glVertex3f( 2.5f,-2.5f, 5.0f);    // Top Right Of The Quad (Bottom)
glVertex3f(-2.5f,-2.5f, 5.0f);    // Top Left Of The Quad (Bottom)
glVertex3f(-2.5f,-2.5f, 0.0f);    // Bottom Left Of The Quad (Bottom)
glVertex3f( 2.5f,-2.5f, 0.0f);    // Bottom Right Of The Quad (Bottom)

glColor3f(1.0f,0.0f,0.0f);     // Color Red
glVertex3f( 2.5f, 2.5f, 5.0f);    // Top Right Of The Quad (Front)
glVertex3f(-2.5f, 2.5f, 5.0f);    // Top Left Of The Quad (Front)
glVertex3f(-2.5f,-2.5f, 5.0f);    // Bottom Left Of The Quad (Front)
glVertex3f( 2.5f,-2.5f, 5.0f);    // Bottom Right Of The Quad (Front)

glColor3f(1.0f,1.0f,0.0f);     // Color Yellow
glVertex3f( 2.5f,-2.5f, 0.0f);    // Top Right Of The Quad (Back)
glVertex3f(-2.5f,-2.5f, 0.0f);    // Top Left Of The Quad (Back)
glVertex3f(-2.5f, 2.5f, 0.0f);    // Bottom Left Of The Quad (Back)
glVertex3f( 2.5f, 2.5f, 0.0f);    // Bottom Right Of The Quad (Back)

glColor3f(0.0f,0.0f,1.0f);     // Color Blue
glVertex3f(-2.5f, 2.5f, 5.0f);    // Top Right Of The Quad (Left)
glVertex3f(-2.5f, 2.5f, 0.0f);    // Top Left Of The Quad (Left)
glVertex3f(-2.5f,-2.5f, 0.0f);    // Bottom Left Of The Quad (Left)
glVertex3f(-2.5f,-2.5f, 5.0f);    // Bottom Right Of The Quad (Left)

glColor3f(1.0f,0.0f,1.0f);     // Color Violet
glVertex3f( 2.5f, 2.5f, 0.0f);    // Top Right Of The Quad (Right)
glVertex3f( 2.5f, 2.5f, 5.0f);    // Top Left Of The Quad (Right)
glVertex3f( 2.5f,-2.5f, 5.0f);    // Bottom Left Of The Quad (Right)
glVertex3f( 2.5f,-2.5f, 0.0f);    // Bottom Right Of The Quad (Right)

   glEnd();
*/

glutSwapBuffers(); //swap the buffers
angle++; //increase the angle
}

void reshape (int w, int h) {
glViewport (0, 0, (GLsizei)w, (GLsizei)h); //set the viewport to the current window specifications
glMatrixMode (GL_PROJECTION); //set the matrix to projection
glLoadIdentity ();
gluPerspective (60, (GLfloat)w / (GLfloat)h, 0.1, 1000.0); //set the perspective (angle of sight, width, height, , depth)
glMatrixMode (GL_MODELVIEW); //set the matrix back to model
}

void keyboard (unsigned char key, int x, int y) {


if (key=='b')
{

cout << "Posicion" << i+1 << endl;
cout << array[i+1][0] << endl << array[i+1][1] << endl << array[i+1][2] <<
endl;
cout << array2[i+1] << endl << endl;
i++;
}


if (key=='q')
{
xrot += 1;
cout << xrot << endl;
if (xrot >360) xrot -= 360;
}

if (key=='z')
{
xrot -= 1;
if (xrot < -360) xrot += 360;
}

if (key=='w')
{
zpos += 0.1;
cout << "Zpos:" << zpos << endl;

}

if (key=='s')
{
zpos -= 0.1;
cout << "Zpos:" << zpos << endl;

}


if (key=='j')
{
xpos += 0.1;
cout << "Xpos:" << xpos << endl;
}


if (key=='l')
{
xpos -= 0.1;
cout << "Xpos:" << xpos << endl;
}


if (key=='i')
{
ypos += 0.1;
cout << "Ypos:" << ypos << endl;
}


if (key=='k')
{
ypos -= 0.1;
cout << "Ypos:" << ypos << endl;
}

/*
if (key=='w')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos += float(sin(yrotrad)) ;
zpos -= float(cos(yrotrad)) ;
ypos -= float(sin(xrotrad)) ;
}

if (key=='s')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos -= float(sin(yrotrad));
zpos += float(cos(yrotrad)) ;
ypos += float(sin(xrotrad));
}
*/
/*
if (key=='j')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos += float(sin(yrotrad)) ;
zpos -= float(cos(yrotrad)) ;
ypos -= float(sin(xrotrad)) ;
}

if (key=='l')
{
float xrotrad, yrotrad;
yrotrad = (yrot / 180 * 3.141592654f);
xrotrad = (xrot / 180 * 3.141592654f);
xpos -= float(sin(yrotrad));
zpos += float(cos(yrotrad)) ;
ypos += float(sin(xrotrad));
}

*/
if (key=='d')
{
yrot += 1;
if (yrot >360) yrot -= 360;
cout << "Yrot:" << yrot << endl;
}

if (key=='a')
{
yrot -= 1;
if (yrot < -360)yrot += 360;
cout << "Yrot:" << yrot << endl;
}


if (key==27)
{
exit(0);
}
}

int main (int argc, char **argv)
{
   glutInit (&argc, argv);
glutInitDisplayMode (GLUT_DOUBLE | GLUT_DEPTH); //set the display to Double buffer, with depth
glutInitWindowSize (500, 500); //set the window size
glutInitWindowPosition (100, 100); //set the position of the window
   glutCreateWindow ("A basic OpenGL Window"); //the caption of the window
init (); //call the init function
   glutDisplayFunc (display); //use the display function to draw everything
glutIdleFunc (display); //update any variables in display, display can be changed to anyhing, as long as you move the variables to be updated, in this case, angle++;
glutReshapeFunc (reshape); //reshape the window accordingly
glutKeyboardFunc (keyboard); //check the keyboard
   glutMainLoop (); //call the main loop
   return 0;
}