void ModelManager::loadOBJModel(int index) { if(this->model != NULL) free(this->model); // read an OBJ model here if(this->displayModel != NULL) glmDelete(this->displayModel); this->displayModel = glmReadOBJ((char*)this->modelNameList[index].c_str()); printf("%s\n", this->modelNameList[index].c_str()); // traverse the color model this->model = new Model(); this->traverseColorModel(this->displayModel); // print object info printf("x=[%f, %f] dx=%f\n", this->model->minVal[0], this->model->maxVal[0], this->model->xLen); printf("y=[%f, %f] dy=%f\n", this->model->minVal[1], this->model->maxVal[1], this->model->yLen); printf("z=[%f, %f] dz=%f\n\n", this->model->minVal[2], this->model->maxVal[2], this->model->zLen); }
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(); }
COBJNode::~COBJNode(void) { // clean up if(_model_p != NULL) { glDeleteLists(_modelDL, 1); glmDelete(_model_p); _model_p = NULL; } }
JNIEXPORT void JNICALL JNIFUNCTION_DEMO(demoSurfaceCreated(JNIEnv* env, jobject object)) { glStateCacheFlush(); // Make sure we don't hold outdated OpenGL state. for (int i = 0; i < NUM_MODELS; i++) { if (models[i].obj) { glmDelete(models[i].obj, 0); models[i].obj = NULL; } } }
void ofxObjLoader::save(string path, ofMesh& mesh){ path = ofToDataPath(path); GLuint writeMode = GLM_NONE; GLMmodel* m = new GLMmodel(); if(mesh.getNumVertices() > 0){ m->numvertices = mesh.getNumVertices(); m->vertices = new GLfloat[m->numvertices*3+1]; memcpy(&m->vertices[3], &mesh.getVertices()[0].x, sizeof(ofVec3f) * mesh.getNumVertices()); } else { ofLogError("ofxObjLoader::save -- No vertices to save!"); return; } if(mesh.getNumNormals() > 0){ m->numnormals = mesh.getNumNormals(); m->normals = new GLfloat[m->numnormals*3+1]; memcpy(&m->normals[3], &mesh.getNormals()[0].x, sizeof(ofVec3f)*mesh.getNumNormals()); writeMode |= GLM_SMOOTH; } if(mesh.getNumTexCoords() > 0){ m->numtexcoords = mesh.getNumTexCoords(); m->texcoords = new GLfloat[m->numtexcoords*2+1]; memcpy(&m->texcoords[2], &mesh.getTexCoords()[0].x, sizeof(ofVec2f)*mesh.getNumTexCoords()); writeMode |= GLM_TEXTURE; } if(mesh.getNumIndices() > 0){ //create triangles m->numtriangles = mesh.getNumIndices()/3; m->triangles = new GLMtriangle[m->numtriangles]; //add them all to one group m->groups = new GLMgroup(); m->groups->next = NULL; m->groups->material = NULL; string name = "ofMesh"; m->groups->name = (char*)malloc(sizeof(char) * name.length()+1); strcpy(m->groups->name, name.c_str()); m->groups->numtriangles = mesh.getNumIndices()/3; m->groups->triangles = new GLuint[m->groups->numtriangles]; m->numgroups = 1; for(int i = 0; i < mesh.getNumIndices()/3; i++){ memcpy(m->triangles[i].vindices, &mesh.getIndices()[i*3], sizeof(GLuint)*3); memcpy(m->triangles[i].nindices, &mesh.getIndices()[i*3], sizeof(GLuint)*3); memcpy(m->triangles[i].tindices, &mesh.getIndices()[i*3], sizeof(GLuint)*3); m->groups->triangles[i] = i; } } glmWriteOBJ(m, (char*)path.c_str(), writeMode); glmDelete(m); }
int main(int argc, char ** argv) { //get into a rendering loop initAndRunLViewer(screenWidth, screenHeight, render, init); //free the model obj glmDelete(OBJ); return 0; }
void CloseModels() { int i,j; for(j = 0;j < MaxModels;j++) { for(i=0;i <= ModelList[j].numFrames;i++) { if(ModelList[j].object[i] != NULL)glmDelete(ModelList[j].object[i]); } } }
OFX_OBJLOADER_BEGIN_NAMESPACE void load(string path, ofMesh& mesh, bool generateNormals, bool flipFace) { path = ofToDataPath(path); mesh.clear(); GLMmodel* m; m = glmReadOBJ((char*)path.c_str()); if (generateNormals) { glmFacetNormals(m); glmVertexNormals(m, 90); } if (flipFace) { glmReverseWinding(m); } for (int j = 0; j < m->numtriangles; j++) { const GLMtriangle &tri = m->triangles[j]; for (int k = 0; k < 3; k++) { GLfloat *v = m->vertices + (tri.vindices[k] * 3); mesh.addVertex(ofVec3f(v[0], v[1], v[2])); if (m->colors) { GLfloat *c = m->colors + (tri.vindices[k] * 3); mesh.addColor(ofFloatColor(c[0], c[1], c[2])); } if (m->normals && ofInRange(tri.nindices[k], 0, m->numnormals)) { GLfloat *n = m->normals + (tri.nindices[k] * 3); mesh.addNormal(ofVec3f(n[0], n[1], n[2])); } if (m->texcoords && ofInRange(tri.tindices[k], 0, m->numtexcoords)) { GLfloat *c = m->texcoords + (tri.tindices[k] * 2); mesh.addTexCoord(ofVec2f(c[0], c[1])); } } } glmDelete(m); }
//----------------------------------------------------------------------------- // initialize the class //----------------------------------------------------------------------------- bool C3DObject_Init() { if (m_poModel) { free(m_poModel); m_poModel = NULL; } glmDelete(m_poModel); return true; }
void FreeModel(Model *model) { int i; model->used--; if(model->used == 0) { strcpy(model->filename,"\0"); for(i=0;i <= model->numFrames;i++) { glmDelete(model->object[i]); } } }
ARTApp::~ARTApp() { arPattDetach(arHandle); arPattDeleteHandle(pattHandle); arVideoCapStop(); ar3DDeleteHandle(&ar3DHandle); arDeleteHandle(arHandle); arParamLTFree(&cParam); arVideoClose(); if (objModel) glmDelete(objModel); }
Model::~Model(void) { if(model) glmDelete(model); if(colors) delete[] colors; if(bbox) delete bbox; unbindVBO(); deleteVBO(); }
static void cleanup(void) { arglCleanup(gArglSettings); gArglSettings = NULL; arPattDetach(gARHandle); arPattDeleteHandle(gARPattHandle); arVideoCapStop(); ar3DDeleteHandle(&gAR3DHandle); arDeleteHandle(gARHandle); arParamLTFree(&gCparamLT); arVideoClose(); if (gObj != NULL) { glmDelete(gObj); gObj = NULL; } }
int main(int argc, char **argv) { // glut init glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); // create window glutInitWindowPosition(800, 150); glutInitWindowSize(uiWidth, uiHeight); glutCreateWindow("10420 CS550000 CG HW4 TA"); glewInit(); if(glewIsSupported("GL_VERSION_2_0")){ printf("Ready for OpenGL 2.0\n"); }else{ printf("OpenGL 2.0 not supported\n"); system("pause"); exit(1); } glutDisplayFunc(onDisplay); glutIdleFunc(onDisplay); glutReshapeFunc(onWindowReshape); glutMouseFunc(onMouse); glutMotionFunc(onMouseMotion); glutKeyboardFunc(onKeyboard); glutSpecialFunc(onKeyboardSpecial); // init preTranslateX = preTranslateY = 0; scale = 1.0; currentModel = 0; loadModel(currentModel); setShaders(); glEnable(GL_DEPTH_TEST); glEnable(GL_CULL_FACE); glCullFace(GL_BACK); glutMainLoop(); glmDelete(OBJ); return 0; }
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; }
int main(int argc, char **argv) { // glut init glutInit(&argc, argv); glutInitDisplayMode(GLUT_DEPTH | GLUT_DOUBLE | GLUT_RGBA); // create window glutInitWindowPosition(460, 40); glutInitWindowSize(800, 800); glutCreateWindow("10320 CS550000 CG HW2 TA"); glewInit(); if(glewIsSupported("GL_VERSION_2_0")){ printf("Ready for OpenGL 2.0\n"); }else{ printf("OpenGL 2.0 not supported\n"); system("pause"); exit(1); } // load obj models through glm loadOBJModel(); // register glut callback functions glutDisplayFunc (renderScene); glutIdleFunc (idle); glutKeyboardFunc(processNormalKeys); glutMouseFunc (processMouse); glutMotionFunc (processMouseMotion); glEnable(GL_DEPTH_TEST); // set up shaders here setShaders(); // main loop glutMainLoop(); // free glmDelete(OBJ); return 0; }
void ModelManager::loadOBJModel(int index) { if (this->model != NULL) free(this->model); // read an OBJ model here if (this->displayModel != NULL) glmDelete(this->displayModel); this->displayModel = glmReadOBJ((char*)this->modelNameList[index].c_str()); printf("%s\n", this->modelNameList[index].c_str()); // traverse the color model this->model = new Model(); this->traverseColorModel(this->displayModel); //glmFacetNormals(this->displayModel); //glmVertexNormals(this->displayModel, 90.0); // set normalization matrix this->setNormalizeMatrix(); // print object info printf("x = [%.6f, %.6f] dx=%.6f\n", this->model->minVal[0], this->model->maxVal[0], this->model->xLen); printf("y = [%.6f, %.6f] dy=%.6f\n", this->model->minVal[1], this->model->maxVal[1], this->model->yLen); printf("z = [%.6f, %.6f] dz=%.6f\n\n", this->model->minVal[2], this->model->maxVal[2], this->model->zLen); }
void save(string path, const ofMesh& mesh_, const ofPixels& tex, string imgext) { ofMesh mesh = mesh_; path = ofToDataPath(path); ofFilePath::createEnclosingDirectory(path); GLuint writeMode = GLM_NONE; GLMmodel* m = new GLMmodel(); { ofFile file(path); string base_path = file.getEnclosingDirectory(); string material_name = file.getBaseName(); string image_name = material_name + "." + imgext; ofPixels pix = tex; // flip save texture pix.mirror(true, false); ofSaveImage(pix, ofFilePath::join(base_path, image_name)); string mtl_filename = material_name + ".mtl"; writeMode |= GLM_MATERIAL; m->mtllibname = (char*)malloc(mtl_filename.size()); strcpy(m->mtllibname, mtl_filename.c_str()); m->nummaterials = 1; m->materials = (GLMmaterial*)malloc(sizeof(GLMmaterial)); GLMmaterial *mat = &m->materials[0]; memset(mat, 0, sizeof(GLMmaterial)); for (int i = 0; i < 4; i++) { mat->diffuse[i] = 1; mat->ambient[i] = 1; mat->specular[i] = 1; mat->emmissive[i] = 1; } mat->shininess = 1; mat->name = (char*)malloc(material_name.size()); strcpy(mat->name, material_name.c_str()); mat->texture_path = (char*)malloc(image_name.size()); strcpy(mat->texture_path, image_name.c_str()); } if (mesh.getNumVertices() > 0) { m->numvertices = mesh.getNumVertices(); m->vertices = new GLfloat[(m->numvertices + 1) * 3]; memcpy(&m->vertices[3], &mesh.getVertices()[0].x, sizeof(ofVec3f) * mesh.getNumVertices()); } else { ofLogError("ofxObjLoader::save -- No vertices to save!"); return; } if (mesh.getNumNormals() > 0) { m->numnormals = mesh.getNumNormals(); m->normals = new GLfloat[(m->numnormals + 1) * 3]; vector<ofVec3f> normals = mesh.getNormals(); memcpy(&m->normals[3], &normals[0].x, sizeof(ofVec3f) * normals.size()); writeMode |= GLM_SMOOTH; } if (mesh.getNumTexCoords() > 0) { m->numtexcoords = mesh.getNumTexCoords(); m->texcoords = new GLfloat[(m->numtexcoords + 1) * 2]; memcpy(&m->texcoords[2], &mesh.getTexCoords()[0].x, sizeof(ofVec2f) * mesh.getNumTexCoords()); writeMode |= GLM_TEXTURE; } if (mesh.getNumIndices() > 0) { m->numtriangles = mesh.getNumIndices() / 3; m->triangles = new GLMtriangle[m->numtriangles]; m->groups = new GLMgroup(); m->groups->next = NULL; m->groups->material = NULL; string name = "ofMesh"; m->groups->name = (char*)malloc(sizeof(char) * name.length() + 1); strcpy(m->groups->name, name.c_str()); m->groups->numtriangles = mesh.getNumIndices() / 3; m->groups->triangles = new GLuint[m->groups->numtriangles]; m->numgroups = 1; for (int i = 0; i < mesh.getNumIndices(); i += 3) { int idx = i / 3; for (int j = 0; j < 3; j++) { m->triangles[idx].vindices[j] = mesh.getIndices()[i + j] + 1; m->triangles[idx].nindices[j] = mesh.getIndices()[i + j] + 1; m->triangles[idx].tindices[j] = mesh.getIndices()[i + j] + 1; } m->groups->triangles[idx] = idx; } } else { m->numtriangles = mesh.getNumVertices() / 3; m->triangles = new GLMtriangle[m->numtriangles]; m->groups = new GLMgroup(); m->groups->next = NULL; m->groups->material = NULL; string name = "ofMesh"; m->groups->name = (char*)malloc(sizeof(char) * name.length() + 1); strcpy(m->groups->name, name.c_str()); m->groups->numtriangles = mesh.getNumVertices() / 3; m->groups->triangles = new GLuint[m->groups->numtriangles]; m->numgroups = 1; for (int i = 0; i < mesh.getNumVertices(); i += 3) { int idx = i / 3; for (int j = 0; j < 3; j++) { m->triangles[idx].vindices[j] = i + j + 1; m->triangles[idx].nindices[j] = i + j + 1; m->triangles[idx].tindices[j] = i + j + 1; } m->groups->triangles[idx] = idx; } } glmWriteOBJ(m, (char*)path.c_str(), writeMode); glmDelete(m); }
int loadModelRaw( const char* filename, int* num_triangles, int** triangle_indices, int* num_vertices, float** vertices, float bbox_min[3], float bbox_max[3] ) { // Init all output variables to zero as failure state SET_ZERO_IF_NOT_NULL( num_triangles ); SET_ZERO_IF_NOT_NULL( triangle_indices ); SET_ZERO_IF_NOT_NULL( num_vertices ); SET_ZERO_IF_NOT_NULL( vertices ); // Now report error if any are NULL REQUIRE_NOT_NULL( num_triangles ); REQUIRE_NOT_NULL( triangle_indices ); REQUIRE_NOT_NULL( num_vertices ); REQUIRE_NOT_NULL( vertices ); if( ObjLoader::isMyFile( filename ) ) { GLMmodel* model = glmReadOBJ( filename ); if( !model ) { std::cerr << "loadModelRaw: glmReadOBJ( " << filename << ") failed." << std::endl; return 0; } // // Vertices // *num_vertices = model->numvertices; *vertices = new (std::nothrow) float[ *num_vertices*3 ]; if( !(*vertices) ) { std::cerr << "loadModelRaw: failed to allocate memory."; return 0; } std::copy( model->vertices + 3, // Skip dummy vert model->vertices + 3 + model->numvertices*3, *vertices ); // // Triangle indices // *num_triangles = model->numtriangles; *triangle_indices = new (std::nothrow) int[ *num_triangles*3 ]; if( !(*triangle_indices) ) { std::cerr << "loadModelRaw: failed to allocate memory."; return 0; } for( int i=0; i < *num_triangles; ++i ) { (*triangle_indices)[ 3*i+0 ] = model->triangles[i].vindices[0]-1; // (*triangle_indices)[ 3*i+1 ] = model->triangles[i].vindices[1]-1; // Account for dummy vert (*triangle_indices)[ 3*i+2 ] = model->triangles[i].vindices[2]-1; // } glmBoundingBox( model, bbox_min, bbox_max ); glmDelete( model ); return 1; } else { std::cerr << "loadModelRaw: '" << filename << "' extension not recognized." << std::endl; return 0; } }
Object::~Object() { glmDelete(model); }
void destroyCarDrawer(CarDrawer* carDrawer) { glmDelete(carDrawer->carModel); free(carDrawer); }
void Mesh::Preprocess( Scene *s ) { if (displayListID>0) return; if (modelType == TYPE_HEM_FILE) { if (renderMode == MESH_RENDER_AS_DISPLAY_LIST) { displayListID = hem->CreateOpenGLDisplayList( WITH_NORMALS ); if (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) displayListID_low = hem_lowRes->CreateOpenGLDisplayList( WITH_NORMALS ); if (flags & OBJECT_FLAGS_ALLOWDRAWEDGESONLY) hem->CreateOpenGLDisplayList( USE_LINES | WITH_NORMALS | WITH_ADJACENT_FACE_NORMS ); if ( (flags & OBJECT_FLAGS_ALLOWDRAWEDGESONLY) && (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) ) hem_lowRes->CreateOpenGLDisplayList( USE_LINES | WITH_NORMALS | WITH_ADJACENT_FACE_NORMS ); } else if (renderMode == MESH_RENDER_AS_VBO_VERTEX_ARRAY) { interleavedVertDataVBO = hem->CreateOpenGLVBO( WITH_NORMALS ); if (flags & OBJECT_FLAGS_ALLOWDRAWEDGESONLY) hem->CreateOpenGLVBO( USE_LINES | WITH_NORMALS | WITH_ADJACENT_FACE_NORMS ); if (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) interleavedVertDataVBO_low = hem_lowRes->CreateOpenGLVBO( WITH_NORMALS ); if ( (flags & OBJECT_FLAGS_ALLOWDRAWEDGESONLY) && (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) ) hem_lowRes->CreateOpenGLVBO( USE_LINES | WITH_NORMALS | WITH_ADJACENT_FACE_NORMS ); } } else if (modelType == TYPE_OBJ_FILE || modelType == TYPE_SMF_FILE) { if (renderMode == MESH_RENDER_AS_DISPLAY_LIST) { displayListID = glmList( glm, GLM_SMOOTH ); if (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) displayListID_low = glmList( glm_lowRes, GLM_SMOOTH ); } else if (renderMode == MESH_RENDER_AS_VBO_VERTEX_ARRAY) { // Setup element vertex array for vertex buffer objects unsigned int *arrayIndices = (unsigned int *)malloc( glm->numtriangles * 3 * sizeof( unsigned int ) ); for (unsigned int i=0; i<glm->numtriangles; i++) { arrayIndices[3*i+0] = glm->triangles[i].vindices[0]; arrayIndices[3*i+1] = glm->triangles[i].vindices[1]; arrayIndices[3*i+2] = glm->triangles[i].vindices[2]; } glGenBuffers( 1, &elementVBO ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, elementVBO ); glBufferData( GL_ELEMENT_ARRAY_BUFFER, glm->numtriangles*3*sizeof(unsigned int), arrayIndices, GL_STATIC_DRAW ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); free( arrayIndices ); // Setup data array for vertex buffer objects unsigned int dataSize = (glm->numvertices+1)*6*sizeof(float); float *floatData = (float *)malloc( dataSize ); float *fptr = floatData; for (unsigned int i=0; i<(glm->numvertices+1)*3; i+=3) { *(fptr++) = glm->normArray[i]; *(fptr++) = glm->normArray[i+1]; *(fptr++) = glm->normArray[i+2]; *(fptr++) = glm->vertices[i]; *(fptr++) = glm->vertices[i+1]; *(fptr++) = glm->vertices[i+2]; } glGenBuffers( 1, &interleavedVertDataVBO ); glBindBuffer( GL_ARRAY_BUFFER, interleavedVertDataVBO ); glBufferData( GL_ARRAY_BUFFER, dataSize, floatData, GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); free( floatData ); elementCount = glm->numtriangles*3; if (objectOptionFlags & OBJECT_OPTION_USE_LOWRES) { // Setup element vertex array for vertex buffer objects arrayIndices = (unsigned int *)malloc( glm_lowRes->numtriangles * 3 * sizeof( unsigned int ) ); for (unsigned int i=0; i<glm_lowRes->numtriangles; i++) { arrayIndices[3*i+0] = glm_lowRes->triangles[i].vindices[0]; arrayIndices[3*i+1] = glm_lowRes->triangles[i].vindices[1]; arrayIndices[3*i+2] = glm_lowRes->triangles[i].vindices[2]; } glGenBuffers( 1, &elementVBO_low ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, elementVBO_low ); glBufferData( GL_ELEMENT_ARRAY_BUFFER, glm_lowRes->numtriangles*3*sizeof(unsigned int), arrayIndices, GL_STATIC_DRAW ); glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 ); free( arrayIndices ); // Setup data array for vertex buffer objects dataSize = (glm_lowRes->numvertices+1)*6*sizeof(float); floatData = (float *)malloc( dataSize ); fptr = floatData; for (unsigned int i=0; i<(glm_lowRes->numvertices+1)*3; i+=3) { *(fptr++) = glm_lowRes->normArray[i]; *(fptr++) = glm_lowRes->normArray[i+1]; *(fptr++) = glm_lowRes->normArray[i+2]; *(fptr++) = glm_lowRes->vertices[i]; *(fptr++) = glm_lowRes->vertices[i+1]; *(fptr++) = glm_lowRes->vertices[i+2]; } glGenBuffers( 1, &interleavedVertDataVBO_low ); glBindBuffer( GL_ARRAY_BUFFER, interleavedVertDataVBO_low ); glBufferData( GL_ARRAY_BUFFER, dataSize, floatData, GL_STATIC_DRAW ); glBindBuffer( GL_ARRAY_BUFFER, 0 ); free( floatData ); elementCount_low = glm_lowRes->numtriangles*3; } } } if (glm) glmDelete( glm ); //if (hem) hem->FreeNonGLMemory(); }
void saveGroup(string path, const vector<ofMesh> & meshGroup, bool flipFace, bool flipNormals) { path = ofToDataPath(path); ofFilePath::createEnclosingDirectory(path); GLuint writeMode = GLM_NONE; GLMmodel * m = new GLMmodel(); GLMgroup * group = NULL; int numOfVerticesTotal = 0; int numOfNormalsTotal = 0; int numOfTexCoordsTotal = 0; int numOfIndicesTotal = 0; int numOfTrianglesTotal = 0; for(int i=0; i<meshGroup.size(); i++) { const ofMesh & mesh = meshGroup[i]; numOfVerticesTotal += mesh.getNumVertices(); numOfNormalsTotal += mesh.getNumNormals(); numOfTexCoordsTotal += mesh.getNumTexCoords(); if(mesh.getNumIndices() > 0) { numOfIndicesTotal += mesh.getNumIndices(); } else { numOfIndicesTotal += mesh.getNumVertices(); } } // glm skips the first array element when exporting. // not sure why? // but it means everything needs to be padded by 1. numOfVerticesTotal += 1; numOfNormalsTotal += 1; numOfTexCoordsTotal += 1; if(numOfVerticesTotal > 0) { m->numvertices = numOfVerticesTotal; m->vertices = new GLfloat[m->numvertices * 3]; } if(numOfNormalsTotal > 0) { m->numnormals = numOfNormalsTotal; m->normals = new GLfloat[m->numnormals * 3]; } if(numOfTexCoordsTotal > 0) { m->numtexcoords = numOfTexCoordsTotal; m->texcoords = new GLfloat[m->numtexcoords * 2]; } if(numOfIndicesTotal > 0) { numOfTrianglesTotal = numOfIndicesTotal / 3; m->numtriangles = numOfTrianglesTotal; m->triangles = new GLMtriangle[m->numtriangles]; } int numOfVertices = 0; int numOfNormals = 0; int numOfTexCoords = 0; int numOfIndices = 0; int numOfTriangles = 0; int indexVertices = 1; int indexNormals = 1; int indexTexCoords = 1; int indexIndices = 0; int indexTriangles = 0; for(int k=0; k<meshGroup.size(); k++) { const ofMesh & mesh = meshGroup[k]; if(numOfVerticesTotal > 0) { numOfVertices = mesh.getNumVertices(); memcpy(&m->vertices[indexVertices * 3], &mesh.getVertices()[0].x, sizeof(ofVec3f) * numOfVertices); indexVertices += numOfVertices; } else { ofLogError("ofxObjLoader::save -- No vertices to save!"); return; } if(numOfNormalsTotal > 0) { numOfNormals = mesh.getNumNormals(); vector<ofVec3f> normals = mesh.getNormals(); if(flipNormals) { for(int i = 0; i < normals.size(); i++) { normals[i] *= -1; } } memcpy(&m->normals[indexNormals * 3], &normals[0].x, sizeof(ofVec3f) * numOfNormals); indexNormals += numOfNormals; writeMode |= GLM_SMOOTH; } if(numOfTexCoordsTotal > 0) { numOfTexCoords = mesh.getNumTexCoords(); memcpy(&m->texcoords[indexTexCoords * 2], &mesh.getTexCoords()[0].x, sizeof(ofVec2f) * numOfTexCoords); indexTexCoords += numOfTexCoords; writeMode |= GLM_TEXTURE; } numOfIndices = mesh.getNumIndices(); if(numOfIndices > 0) { numOfTriangles = numOfIndices / 3; } else { numOfTriangles = numOfVertices / 3; } GLMgroup * groupPrev = group; group = new GLMgroup(); group->next = NULL; group->material = NULL; if(m->groups == NULL) { m->groups = group; m->numgroups = 1; } if(groupPrev != NULL) { groupPrev->next = group; m->numgroups += 1; } string name = "ofMesh_" + ofToString(k); group->name = (char*)malloc(sizeof(char) * name.length() + 1); strcpy(group->name, name.c_str()); group->numtriangles = numOfTriangles; group->triangles = new GLuint[group->numtriangles]; const vector<ofIndexType> & indices = mesh.getIndices(); int index = 0; for(int i=0; i<numOfTriangles; i++) { int t = i + indexTriangles; for(int j=0; j<3; j++) { int idx = i * 3 + j; if(numOfIndices > 0) { index = indices[idx]; } else { index = idx; } index += (indexIndices + 1); m->triangles[t].vindices[j] = index; m->triangles[t].nindices[j] = index; m->triangles[t].tindices[j] = index; } group->triangles[i] = t; } indexIndices += numOfVertices; indexTriangles += numOfTriangles; } if(flipFace == true) { glmReverseWinding(m); } glmWriteOBJ(m, (char*)path.c_str(), writeMode); glmDelete(m); }
ModelOBJ::~ModelOBJ(){ if(model){ glmDelete(model); } }
cModelLoader::~cModelLoader() { glmDelete(m_model); }
ModelManager::~ModelManager() { if(this->displayModel != NULL) glmDelete(this->displayModel); }
void keyboard(unsigned char key, int x, int y) { GLint params[2]; switch (key) { case 'h': printf("help\n\n"); printf("w - Toggle wireframe/filled\n"); printf("c - Toggle culling\n"); printf("n - Toggle facet/smooth normal\n"); printf("b - Toggle bounding box\n"); printf("r - Reverse polygon winding\n"); printf("m - Toggle color/material/none mode\n"); printf("p - Toggle performance indicator\n"); printf("s/S - Scale model smaller/larger\n"); printf("t - Show model stats\n"); printf("o - Weld vertices in model\n"); printf("+/- - Increase/decrease smoothing angle\n"); printf("W - Write model to file (out.obj)\n"); printf("q/escape - Quit\n\n"); break; case 't': stats = !stats; break; case 'p': performance = !performance; break; case 'm': material_mode++; if (material_mode > 2) material_mode = 0; printf("material_mode = %d\n", material_mode); lists(); break; case 'd': glmDelete(model); init(); lists(); break; case 'w': glGetIntegerv(GL_POLYGON_MODE, params); if (params[0] == GL_FILL) glPolygonMode(GL_FRONT_AND_BACK, GL_LINE); else glPolygonMode(GL_FRONT_AND_BACK, GL_FILL); break; case 'c': if (glIsEnabled(GL_CULL_FACE)) glDisable(GL_CULL_FACE); else glEnable(GL_CULL_FACE); break; case 'b': bounding_box = !bounding_box; break; case 'n': facet_normal = !facet_normal; lists(); break; case 'r': glmReverseWinding(model); lists(); break; case 's': glmScale(model, 0.8); lists(); break; case 'S': glmScale(model, 1.25); lists(); break; case 'o': //printf("Welded %d\n", glmWeld(model, weld_distance)); glmVertexNormals(model, smoothing_angle); lists(); break; case 'O': weld_distance += 0.01; printf("Weld distance: %.2f\n", weld_distance); glmWeld(model, weld_distance); glmFacetNormals(model); glmVertexNormals(model, smoothing_angle); lists(); break; case '-': smoothing_angle -= 1.0; printf("Smoothing angle: %.1f\n", smoothing_angle); glmVertexNormals(model, smoothing_angle); lists(); break; case '+': smoothing_angle += 1.0; printf("Smoothing angle: %.1f\n", smoothing_angle); glmVertexNormals(model, smoothing_angle); lists(); break; case 'W': glmScale(model, 1.0/scale); glmWriteOBJ(model, "out.obj", GLM_SMOOTH | GLM_MATERIAL); break; case 'R': { GLuint i; GLfloat swap; for (i = 1; i <= model->numvertices; i++) { swap = model->vertices[3 * i + 1]; model->vertices[3 * i + 1] = model->vertices[3 * i + 2]; model->vertices[3 * i + 2] = -swap; } glmFacetNormals(model); lists(); break; } case 27: exit(0); break; } glutPostRedisplay(); }
void loadGroup(string path, map<string, ofMesh>& groups, bool generateNormals) { path = ofToDataPath(path); groups.clear(); GLMmodel* m; m = glmReadOBJ((char*)path.c_str()); if (generateNormals) { glmFacetNormals(m); } glmReverseWinding(m); GLMgroup *g = m->groups; while (g) { string name = g->name; ofMesh t; GLMtriangle *p = m->triangles; for (int j = 0; j < g->numtriangles; j++) { GLMtriangle tri = p[g->triangles[j]]; for (int k = 0; k < 3; k++) { GLfloat *v = m->vertices + (tri.vindices[k] * 3); t.addVertex(ofVec3f(v[0], v[1], v[2])); if (m->colors) { GLfloat *c = m->colors + (tri.vindices[k] * 3); t.addColor(ofFloatColor(c[0], c[1], c[2])); } if (m->normals && ofInRange(tri.nindices[k], 0, m->numnormals)) { GLfloat *n = m->normals + (tri.nindices[k] * 3); t.addNormal(ofVec3f(n[0], n[1], n[2])); } if (m->texcoords && ofInRange(tri.tindices[k], 0, m->numtexcoords)) { GLfloat *c = m->texcoords + (tri.tindices[k] * 2); t.addTexCoord(ofVec2f(c[0], c[1])); } } } groups[name] = t; g = g->next; } glmDelete(m); }
CGlObjLoader::~CGlObjLoader(){ glmDelete(pmodel); }