Wheel::Wheel(char *tyreFile) { rad = 7; //getTextures(); wheel_model = glmReadOBJ(tyreFile); glmUnitize(wheel_model); glmVertexNormals(wheel_model, 90.0, GL_TRUE); angle = 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; }
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); }
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); }
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); }
//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(); }
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); }
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; }
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); }
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); }
/** * 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; }
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(); }
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); } }
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; }
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; }
////////////////////////////////////////////////////////////////////////// // 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.... }
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); }
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); }
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 }
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; }
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 }
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(); }
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; }
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; }
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 }
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; }
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; }
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); }