Jump to content
  • Advertisement
Sign in to follow this  
tirengarfio

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

This topic is 4112 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

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.alpha;
  MyMaterial (GL_AMBIENT, materials.ambient,alpha);
  MyMaterial (GL_DIFFUSE, materials.diffuse,alpha);
  MyMaterial (GL_SPECULAR, materials.specular,alpha);
  MyMaterial (GL_EMISSION, materials.emission,alpha);
  glMaterialf (GL_FRONT_AND_BACK,GL_SHININESS,materials.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[j];
          int ni=face_indicies[j+3];//Normal index
          int ti=face_indicies[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[0],-array[1],-array[2]);

glRotatef(array2, 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;
}






Share this post


Link to post
Share on other sites
Advertisement
Sign in to follow this  

  • Advertisement
×

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

Participate in the game development conversation and more when you create an account on GameDev.net!

Sign me up!