Beispiel #1
0
Wheel::Wheel(char *tyreFile) {
	rad = 7;
	//getTextures();
	wheel_model = glmReadOBJ(tyreFile);
	glmUnitize(wheel_model);
	glmVertexNormals(wheel_model, 90.0, GL_TRUE);
	angle = 0;
    
    
    
}
Beispiel #2
0
/**
 * Funcion principal del programa
 */
int main (int argc, char** argv){
  static const GLfloat ambient[4] = {1.0f,1.0f,1.0f,1.0f,1.0f};
  //Inicializa la ventana
  glutInit(&argc,argv);
  glutInitWindowSize(600, 600);
  glutInitWindowPosition (10, 50);
  glutCreateWindow("Visualizador de Modelos 3D");
  //Iluminacion (solo para los obj)
  glShadeModel(GL_SMOOTH);
  glLightfv(GL_LIGHT0,GL_AMBIENT,ambient);
  glEnable(GL_LIGHT0);
  //Posicionamos las figuras
  initObjetos();
  modelo_CARRO = glmReadOBJ("objetos/porsche.obj");
  if (!modelo_CARRO) exit (0); //si no existe, exit
  modelo_AVION = glmReadOBJ("objetos/f-16.obj");
  if (!modelo_AVION) exit (0); //si no existe, exit
  //Dibujar escena
  glutDisplayFunc(display);

  //Dibujar acorde a cambios en ventana
  glutReshapeFunc(cambios_ventana);

  //Accion por defecto (al estar idle)
  glutIdleFunc(display);

  //Funcion que activa el input por teclado o mouse
  glutKeyboardFunc(teclado);
  glutSpecialFunc(teclas_esp);
  glutMotionFunc(mouseMove);
  glutMouseFunc(mouseAction);

  glEnable(GL_DEPTH_TEST);

  //Ejecutar todo
  glutMainLoop();

  return 0;
  

}
Beispiel #3
0
void drawmodel_box(void)
{
	if (!pmodel1)
	{
	    pmodel1 = glmReadOBJ("bike1.obj");
        if (!pmodel1) exit(0);
	    glmUnitize(pmodel1);
		glmFacetNormals(pmodel1);
		glmVertexNormals(pmodel1, 90.0);
    }
    glmDraw(pmodel1, GLM_SMOOTH| GLM_TEXTURE);
}
Beispiel #4
0
void drawmodel_box3(void)
{
	if (!pmodel3)
	{
	    pmodel3 = glmReadOBJ("bike3.obj");
        if (!pmodel3) exit(0);
	    glmUnitize(pmodel3);
		glmFacetNormals(pmodel3);
		glmVertexNormals(pmodel3, 90.0);
    }
    glmDraw(pmodel3, GLM_SMOOTH| GLM_TEXTURE);
}
Beispiel #5
0
void drawmodel_box4(void)
{
	if (!pmodel4)
	{
	    pmodel4 = glmReadOBJ("bike4.obj");
        if (!pmodel4) exit(0);
	    glmUnitize(pmodel4);
		glmFacetNormals(pmodel4);
		glmVertexNormals(pmodel4, 90.0);
    }
    glmDraw(pmodel4, GLM_SMOOTH| GLM_TEXTURE);
}
Beispiel #6
0
//Loads a model with a given file name and texture.
void cModelLoader::loadModel(const char* mdlFilename, cTexture mdlTexture)
{
	m_model = glmReadOBJ(mdlFilename);
	glmUnitize(m_model);
	glmFacetNormals(m_model);
	glmVertexNormals(m_model, 180.0f,false);
	m_TextureID = mdlTexture.getTexture();

	m_model->textures[m_model->numtextures - 1].id = m_TextureID;
	m_model->textures[m_model->numtextures - 1].width = mdlTexture.getTWidth();
	m_model->textures[m_model->numtextures - 1].height = mdlTexture.getTHeight();
}
Beispiel #7
0
void drawmodel_box5(void)
{
	if (!pmodel5)
	{
	    pmodel5 = glmReadOBJ("bike5.obj");
        if (!pmodel5) exit(0);
	    glmUnitize(pmodel5);
		glmFacetNormals(pmodel5);
		glmVertexNormals(pmodel5, 90.0);
    }
    glmDraw(pmodel5, GLM_SMOOTH| GLM_TEXTURE);
}
Beispiel #8
0
bool ModelOBJ::Load(char *filename, bool addForCollision)
{
	model = glmReadOBJ(filename);
	if(!model) return false;
    glmUnitize(model);
    glmFacetNormals(model);
    glmVertexNormals(model, 90.0);
	
	if (addForCollision)
		AddToCollisionEngine();

	return true;
}
Beispiel #9
0
void
drawmodel(void)
{
    if (!pmodel) {
        pmodel = glmReadOBJ((char*)"../data/soccerball.obj");
        if (!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }

    glmDraw(pmodel, GLM_SMOOTH);
}
Beispiel #10
0
void
drawmodel(void)
{
    if (!pmodel) {
        pmodel = glmReadOBJ("data/al.obj");
        if (!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }
    
    glmDraw(pmodel, GLM_SMOOTH | GLM_MATERIAL);
}
Beispiel #11
0
	/**
	 * Loads a model from a .obj file and returns the model object.
	 * 
         * @param filename Filename of the model.
         * @return 
         */
	model* obj_loader::load_file(const char* filename) const
	{
		char* fptr = (char*)filename;
		GLMmodel* glm_model = glmReadOBJ(fptr);
	
		//glmUnitize(glm_model);
		glmFacetNormals(glm_model);
		glmVertexNormals(glm_model, 90.0);
		
		model* result = new model(glm_model);
		
		return result;
	}
Beispiel #12
0
void loadOBJModel(int index)
{
	// load model through glm parser
	OBJ = glmReadOBJ(filename[index]);
	printf("%s\n", filename[index]);

	// glm will calculate the vertex normals for you
	// uncomment them only if there is no vertex normal info in your .obj file
//	glmFacetNormals(OBJ);         
//	glmVertexNormals(OBJ, 90.0);  

	// parse texture model and align the vertices
	TextureModel();
}
Beispiel #13
0
CGlObjLoader::CGlObjLoader(char* fname)
{
//    _left = 0.0;		/* ortho view volume params */
//    _right = 0.0;
//    _bottom = 0.0;
//    _top = 0.0;
//    _zNear = 0.1;
//    _zFar = 10.0;
//    fovy = 45.0;
//    prev_z = 0;

    //mode = 0;		/* viewing mode */

//     light_ambient[4] = { 1.0, 1.0, 1.0, 1.0 };
//     light_diffuse[4] = { 1.0, 1.0, 1.0, 1.0 };
//     light_specular[4] = { 1.0, 1.0, 1.0, 1.0 };
//     light_position[4] = { 1.0, 1.0, 1.0, 0.0 };

//     mat_ambient[4] = { 0.7, 0.7, 0.7, 0.0 };
//     mat_diffuse[4] = { 0.8, 0.8, 0.8, 1.0 };
//     mat_specular[4] = { 1.0, 1.0, 1.0, 1.0 };
//     high_shininess[1] = { 100.0 };

    getMatrix();
    glClearColor(0.0, 0.0, 0.0, 0.0);   // glutSetOption(GLUT_ACTION_ON_WINDOW_CLOSE,GLUT_ACTION_GLUTMAINLOOP_RETURNS);
    //glutMainLoop();
    glClearAccum(0.0, 0.0, 0.0, 0.0);

    // if (lighting)
    glEnable(GL_LIGHTING);
    /// if (lighting)
    glEnable(GL_LIGHT0);
    glDepthFunc(GL_LESS);
    glEnable(GL_DEPTH_TEST);
    glEnable(GL_NORMALIZE);
    glEnable(GL_TEXTURE_2D);

    strncpy(filename, fname ,sizeof(filename));	/* get the last arg as the file always */

    if (!pmodel) {		/* load up the model */
        pmodel = glmReadOBJ(filename);
        if (!pmodel) {
            printf("\nUsage: objviewV2 <-s> <obj filename>\n");
            exit(0);
        }
        glmUnitize(pmodel);
        glmVertexNormals(pmodel, 90.0, GL_TRUE);
    }

}
Beispiel #14
0
Canhao::Canhao(char *p_base, char *p_canhao){
    //std::cerr << "Inicio Canhao::Canhao(char *p_base, char *p_canhao)" << std::endl;
    _podeDisparar = true;

    _rotacaoBase = 0;
    _rotacaoCanhao = 0;

    _baseTanque = NULL;
    _canhaoTanque = NULL;

    _tiros.clear();

    if(!_baseTanque) {
        _baseTanque = glmReadOBJ(p_base);
        if(!_baseTanque) std::cerr << "Não foi possível carregar o arquivo .OBJ" << std::endl;
        glmUnitize(_baseTanque);
        glmFacetNormals(_baseTanque);
        glmVertexNormals(_baseTanque,180.0);
    }

    if(!_canhaoTanque) {
        _canhaoTanque = glmReadOBJ(p_canhao);
        if(!_canhaoTanque) std::cerr << "Não foi possível carregar o arquivo .OBJ" << std::endl;
        glmUnitize(_canhaoTanque);
        glmFacetNormals(_canhaoTanque);
        glmVertexNormals(_canhaoTanque,180.0);
    }

    // definir posicao inicial do canhao deste jogador
    _posicaoBase[0] = 0.0;
    _posicaoBase[1] = 0.0;
    _posicaoBase[2] = 0.0;
    _posicaoCanhao[0] = 0.0;
    _posicaoCanhao[1] = 0.2;
    _posicaoCanhao[2] = 0.0;
    //std::cerr << "Fim Canhao::Canhao(char *p_base, char *p_canhao)" << std::endl;
}
Beispiel #15
0
void init(void) { 
	int i;
	for(i=0;i<numSpheres;i++){
		spheres[i][0] = (rand()%600)-300;//XPOS
		spheres[i][1] = (rand()%600)-300;//YPOS
		spheres[i][2] = rand()%400;//ZPOS
		spheres[i][3] = rand()%20;//SIZE
		spheres[i][4] = (rand()%20);//SPEED
	}
   
	MAXROT = 1.0/6.0*PI;
	glClearColor (0.0, 0.0, 0.0, 0.0);
	glEnable(GL_DEPTH_TEST);
	glShadeModel(GL_SMOOTH);
	pmodel = glmReadOBJ("city.obj");
	if (!pmodel) fprintf(stderr,"Cannot parse vase.obj");
	//glmUnitize(pmodel); // make model to fit in a unit cube
	glmFacetNormals(pmodel); // generate normals - is this needed?
	glmVertexNormals(pmodel, 90.0); // average joining normals - allow for hard edges.
	tmodel = glmReadOBJ("tower.obj");
	glmFacetNormals(tmodel); // generate normals - is this needed?
	glmVertexNormals(tmodel, 90.0); // average joining normals - allow for hard edges.
	readTop();
	readFront();
	readBack();
	readRight();
	readLeft();
	readFire();
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);
	glGenTextures(1, &front);
	glGenTextures(1, &top);
	glGenTextures(1, &left);
	glGenTextures(1, &right);
	glGenTextures(1, &back);
	glGenTextures(1, &fire);
	qsphere = gluNewQuadric();
}
int main(int argc, char ** argv)
{
    glutInit(&argc, argv);
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGBA | GLUT_DEPTH);
    glutInitWindowPosition(WINDOW_X_POSITION, WINDOW_Y_POSITION);
    glutInitWindowSize(::nWindowWidth, ::nWindowHeight);

    int window;
    window = glutCreateWindow("AFABLEE_PROJ3_MAC");

    glutDisplayFunc(Display);
    glutReshapeFunc(Reshape);
    glutKeyboardFunc(Keyboard);
    glutSpecialFunc(Special);
    glutTimerFunc(GLUT_TIMER_DELAY, Timer, 0);
    glutMouseFunc(Mouse);
    glutMotionFunc(Motion);

    // check for glm model
    if ( argc > 1 )
    {
        ::model = glmReadOBJ(argv[1]);
        std::cerr << argv[1] << " successfully loaded and will be drawn behind the star king." << std::endl;
    }

    // initialize the rest of the program
    Init();

    // create a right-click menu for feature processing
    int nMainMenu, nPolyMenu;

    nPolyMenu = glutCreateMenu(ProcessMenu);
    glutAddMenuEntry("fill back", MODE_BACK_FILL);
    glutAddMenuEntry("fill front", MODE_FRONT_FILL);
    glutAddMenuEntry("line back", MODE_BACK_LINE);
    glutAddMenuEntry("line front", MODE_FRONT_LINE);
    glutAddMenuEntry("point back", MODE_BACK_POINT);
    glutAddMenuEntry("point front", MODE_FRONT_POINT);

    nMainMenu = glutCreateMenu(ProcessMenu);
    glutAddMenuEntry("arcball", MODE_ARCBALL);
    glutAddMenuEntry("crawler", MODE_CRAWLER);
    glutAddSubMenu("polygon surface modes", nPolyMenu);
    glutAttachMenu(GLUT_RIGHT_BUTTON);

    glutMainLoop();

    return 0;
}
Beispiel #17
0
//////////////////////////////////////////////////////////////////////////
// init()
//	This function will be called once when the program starts.
//////////////////////////////////////////////////////////////////////////
void init(){
	//read an obj model here
	//GLMmodel* OBJ;
	OBJ = glmReadOBJ("bunny5KN.obj");
	MODELS.push_back(OBJ);
	OBJ = glmReadOBJ("duck4KN.obj");
	MODELS.push_back(OBJ);
	OBJ = glmReadOBJ("Nala6KN.obj");
	MODELS.push_back(OBJ);
	//OBJ = glmReadOBJ("cube.obj");
	
	for (int i=0; i<MODELS.size(); ++i) {
		OBJ = MODELS[i];
		//rotate(0, 45.0, 45.0);
		//move the object to the origin
		//scale to -1~+1
		glmUnitize(OBJ);
		scale2Screen(OBJ);
		//calculate the vertex normals
		glmFacetNormals(OBJ);	
		glmVertexNormals(OBJ,90.0);
	}
	//the math library that can be used
	vec3;
	vec4;
	mat3;
	mat4;
	identity3D;
	translation3D;
	rotation3D;
	scaling3D;
	//......
	//cout << OBJ->position[0] << " " << OBJ->position[1] << " " << OBJ->position[2] << endl;

	//maybe u can do some initialization here....
}
Beispiel #18
0
void drawmodel_box(void)
{
    if (!pmodel1)
    {
        pmodel1 = glmReadOBJ("objects/monkey.obj");
        if (!pmodel1) {
            exit(0);
        }
        glmUnitize(pmodel1);
        glmFacetNormals(pmodel1);
        glmVertexNormals(pmodel1, 90.0);
    }
    /* glmDraw(pmodel1, GLM_SMOOTH | GLM_TEXTURE); */
    glmDraw(pmodel1, GLM_SMOOTH);
}
Beispiel #19
0
void init()
{
	glClearColor (.4,.4,.4,1);
	glEnable (GL_DEPTH_TEST);

	glEnable (GL_LIGHTING);
	glEnable (GL_LIGHT0);
	
	al = glmReadOBJ ("al.obj");
	glmUnitize (al);
	glmFacetNormals (al);
	glmVertexNormals (al, 90.0);
	
	floortex = pngBind("marble.png", PNG_NOMIPMAP, PNG_SOLID, NULL, GL_REPEAT, GL_NEAREST, GL_NEAREST);
}
Beispiel #20
0
void init()
{
  glClearColor(0.0, 0.0, 0.0, 0.0);
  glShadeModel(GL_SMOOTH);

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);

  glEnable(GL_DEPTH_TEST);

  glEnable(GL_BLEND);
  glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

  g_pModel = glmReadOBJ(g_strModelFilePath); // call glmDelete when done
}
Beispiel #21
0
bool Model::LoadModel(char* fileName)
{
	if(!mod)
	{
		mod = glmReadOBJ(fileName);

		glmUnitize(mod);

		glmFacetNormals(mod); 
		glmVertexNormals(mod, 90.0);

		return true;
	}

	// model with this name has already been loaded
	return false;
}
Beispiel #22
0
void Player:: drawmodel_fish_mod()
{
	glTranslatef(x, y, -z);
	glRotatef(180-t,0,1,0);

	if (!pmodel2) 
	{
		pmodel2 = glmReadOBJ("fishLL.obj");	 //glm.cpp
        if (!pmodel2) exit(0);
	//	glmUnitize(pmodel1);				 //glm.cpp
		glmFacetNormals(pmodel2);			 //glm.cpp   
		glmVertexNormals(pmodel2, 90.0);     //glm.cpp
    }

    glmDraw(pmodel2, GLM_SMOOTH| GLM_TEXTURE);//glm.cpp
	
}
Beispiel #23
0
void
screen_menu(int value)
{
    char* name = 0;

    switch (value) {
    case 'a':
        name = (char*)"../data/al.obj";
        break;
    case 's':
        name = (char*)"../data/soccerball.obj";
        break;
    case 'd':
        name = (char*)"../data/dolphins.obj";
        break;
    case 'f':
        name = (char*)"../data/flowers.obj";
        break;
    case 'j':
        name = (char*)"../data/f-16.obj";
        break;
    case 'p':
        name = (char*)"../data/porsche.obj";
        break;
    case 'r':
        name = (char*)"../data/rose+vase.obj";
        break;
    case 'n':
        if (pmodel) glmDelete(pmodel);
        pmodel = NULL;
        redisplay_all();
        return;
    }

    if (name) {
        if (pmodel) glmDelete(pmodel);
        pmodel = glmReadOBJ(name);
        if (!pmodel) exit(0);
        glmUnitize(pmodel);
        glmFacetNormals(pmodel);
        glmVertexNormals(pmodel, 90.0);
    }

    redisplay_all();
}
Beispiel #24
0
bool ofxGLM::load(string sFile, float nScale, bool bNormalize) {
	char* filename = (char*)ofToDataPath(sFile, true).c_str();
	model = glmReadOBJ(filename);
	if(!model) {
		ofLog(OF_LOG_ERROR, "Could not load model: %s", sFile.c_str());
		return false;
	}
	if(bNormalize) {
		normalize();
	}
	if(nScale != -1.0) {
		scale(nScale);
	}
	
	createMaterials();
	createGroups();
	return true;
}
Beispiel #25
0
void
init(void)
{
  gltbInit(GLUT_LEFT_BUTTON);
    
  /* read in the model */
  model = glmReadOBJ(model_file);
  scale = glmUnitize(model);
  glmFacetNormals(model);
  glmVertexNormals(model, smoothing_angle);
    
  if (model->nummaterials > 0)
    material_mode = 2;
    
  /* create new display lists */
  lists();
  /*  GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
  
   glLightfv(GL_LIGHT0, GL_POSITION, light_position);

  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
  //glLightModeli(GL_LIGHT_MODEL_TWO_SIDE, GL_TRUE);     
  glEnable(GL_DEPTH_TEST);     
  glEnable(GL_CULL_FACE);
*/

  GLfloat mat_specular[] = { 1.0, 1.0, 1.0, 1.0 };
  GLfloat mat_shininess[] = { 50.0 };
  GLfloat light_position[] = { 1.0, 1.0, 1.0, 0.0 };
  glClearColor (0.0, 0.0, 0.0, 0.0);
  glShadeModel (GL_SMOOTH);
  
  glMaterialfv(GL_FRONT, GL_SPECULAR, mat_specular);
  glMaterialfv(GL_FRONT, GL_SHININESS, mat_shininess);
  glLightfv(GL_LIGHT0, GL_POSITION, light_position);
  
  glEnable(GL_LIGHTING);
  glEnable(GL_LIGHT0);
   glEnable(GL_DEPTH_TEST);


}
void ofxObjLoader::load(string path, ofMesh& mesh, bool generateNormals) {
	path = ofToDataPath(path);
    
    mesh.clear();
    
	GLMmodel* m;
	
	m = glmReadOBJ((char*)path.c_str());
	
    if(generateNormals){
        glmFacetNormals(m);
        glmVertexNormals(m, 90);
    }
    
    GLfloat *v, *n, *c;
    for(int i = 1; i <= m->numvertices; i++){
        v = &m->vertices[3 * i];
		mesh.addVertex(ofVec3f(v[0], v[1], v[2]));
    }
    
	for(int i = 1; i <= m->numnormals; i++){
        n = &m->normals[3 * i];
        mesh.addNormal(ofVec3f(n[0], n[1], n[2]));
    }
    
    for(int i = 1; i <= m->numtexcoords; i++){
        c = &m->texcoords[2 * i];
        mesh.addTexCoord(ofVec2f(c[0], c[1]));
    }
    
	for (int i = 0; i < m->numtriangles; i++) {
		GLMtriangle &t = m->triangles[i];
        
        //NOTE: ofMesh does not have support for different indices for tex coords and mormals
		mesh.addIndex(t.vindices[0]);
        mesh.addIndex(t.vindices[1]);
        mesh.addIndex(t.vindices[2]);
	}
	
	glmDelete(m);
	
	return mesh;
}
Beispiel #27
0
void Player:: drawmodel_fish_mod2()
{

	
	glTranslatef(x, y, -z);
	glRotatef(180-t,0,1,0);

	if (!pmodel3) 
	{
		//printf("Loaded\n");
		pmodel3 = glmReadOBJ("fishRR.obj");	 //glm.cpp
        if (!pmodel3) exit(0);
	//	glmUnitize(pmodel1);				 //glm.cpp
		glmFacetNormals(pmodel3);			 //glm.cpp   
		glmVertexNormals(pmodel3, 90.0);     //glm.cpp
    }

    glmDraw(pmodel3, GLM_SMOOTH| GLM_TEXTURE);//glm.cpp
	
}
Beispiel #28
0
bool load_new_model(const char *pszFilename, GLMmodel **model)
{
    char aszFilename[256];
    strcpy(aszFilename, pszFilename);

    if (*model)
    {
        free(*model);
        *model = NULL;
    }

    *model = glmReadOBJ(aszFilename);
    if (!(*model))
        return false;

    glmUnitize(*model);
    glmFacetNormals(*model);
    glmVertexNormals(*model, 90.0);

    return true;
}
Beispiel #29
0
bool C3DObject_Load_New_Player(const char *pszFilename, GLMmodel **model) {
    char aszFilename[256];
    strcpy(aszFilename, pszFilename);

    if (*model) {

        free(*model);
        *model = NULL;
    }

    *model = glmReadOBJ(aszFilename);
    if (!(*model))
        return false;

    glmUnitize(*model);
    //glmScale(model,sFactor); // USED TO SCALE THE OBJECT
    glmFacetNormals(*model);
    glmVertexNormals(*model, 90.0);

    return true;
}
Beispiel #30
0
void init(void)
{
	glEnable(GL_DEPTH_TEST);
	glClearColor(0.6, 0.6, 0.6, 1);
	glPixelStorei(GL_UNPACK_ALIGNMENT, 1);

	pngLoadRaw("terrain5.png", &info);
	setheight();
	move[1] = bilinear(move[0], move[2]);
	tri[0] = Vec3(0, bilinear(0, 0.5), 0.5);
	tri[1] = Vec3(2.5, bilinear(2.5, 0), 0);
	tri[2] = Vec3(0, bilinear(0, -0.5), -0.5);

	car = glmReadOBJ("porsche.obj");
	glmUnitize(car);
	glmScale(car, 15);
	glmFacetNormals(car);
	glmVertexNormals(car, 90);

	glEnable(GL_TEXTURE_2D);
}