PDA

View Full Version : I cant see the textures of an exported object with Deep Exploration



tirengarfio
03-21-2007, 04:52 AM
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 (&amp;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;
}