bool AURenMesh::LoadFromFileImport( const std::string& strFilename ) { #ifndef NO_ASSIMP Assimp::Importer importer; const aiScene* pScene = importer.ReadFile( strFilename, aiProcessPreset_TargetRealtime_Fast ); if (!pScene || pScene->mNumMeshes == 0) { return false; } ProcessScene(pScene); return true; #else assert( false ); return false; #endif }
void Model::loadModel(std::string path) { // Read file via ASSIMP Assimp::Importer importer; const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); // Check for errors if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) // if is Not Zero { std::cout << "ERROR::ASSIMP:: " << importer.GetErrorString() << std::endl; return; } // Retrieve the directory path of the filepath this->directory = path.substr(0, path.find_last_of('/')); // Process ASSIMP's root node recursively this->processNode(scene->mRootNode, scene); }
TEST_F( utIssues, OpacityBugWhenExporting_727 ) { float opacity; aiScene *scene( TestModelFacttory::createDefaultTestModel( opacity ) ); Assimp::Importer importer; Assimp::Exporter exporter; std::string path = "dae"; const aiExportFormatDesc *desc( exporter.GetExportFormatDescription( 0 ) ); EXPECT_NE( desc, nullptr ); path.append( desc->fileExtension ); EXPECT_EQ( AI_SUCCESS, exporter.Export( scene, desc->id, path ) ); const aiScene *newScene( importer.ReadFile( path, 0 ) ); EXPECT_TRUE( NULL != newScene ); float newOpacity; if ( newScene->mNumMaterials > 0 ) { std::cout << "Desc = " << desc->description << "\n"; EXPECT_EQ( AI_SUCCESS, newScene->mMaterials[ 0 ]->Get( AI_MATKEY_OPACITY, newOpacity ) ); EXPECT_EQ( opacity, newOpacity ); } }
Model::Model(string file) { if (!Globals::File_Exists(FOLDER+file)) { cout << "File " << FOLDER + file << " does not exist. Can not load model." << endl; return; } path = FOLDER + file.substr(0, file.find_last_of('/')) + '/'; Assimp::Importer importer; const aiScene* scene = importer.ReadFile(FOLDER + file, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_GenNormals | aiProcess_CalcTangentSpace); if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { cout << "ERROR::ASSIMP::" << importer.GetErrorString() << endl; return; } processNode(scene->mRootNode, scene); }
// ------------------------------------------------------------------------------------------------ const aiScene* aiImportFileFromMemoryWithProperties( const char* pBuffer, unsigned int pLength, unsigned int pFlags, const char* pHint, const aiPropertyStore* props) { ai_assert(NULL != pBuffer && 0 != pLength); const aiScene* scene = NULL; ASSIMP_BEGIN_EXCEPTION_REGION(); // create an Importer for this file Assimp::Importer* imp = new Assimp::Importer(); // copy properties if(props) { const PropertyMap* pp = reinterpret_cast<const PropertyMap*>(props); ImporterPimpl* pimpl = imp->Pimpl(); pimpl->mIntProperties = pp->ints; pimpl->mFloatProperties = pp->floats; pimpl->mStringProperties = pp->strings; } // and have it read the file from the memory buffer scene = imp->ReadFileFromMemory( pBuffer, pLength, pFlags,pHint); // if succeeded, store the importer in the scene and keep it alive if( scene) { ScenePrivateData* priv = const_cast<ScenePrivateData*>( ScenePriv(scene) ); priv->mOrigImporter = imp; } else { // if failed, extract error code and destroy the import gLastErrorString = imp->GetErrorString(); delete imp; } // return imported data. If the import failed the pointer is NULL anyways ASSIMP_END_EXCEPTION_REGION(const aiScene*); return scene; }
MeshData LoadMesh( const std::string& pFile) { MeshData mesh; //check if file exists std::ifstream fin(pFile.c_str()); if(!fin.fail()) { fin.close(); } else { printf("Couldn't open file: %s\n", pFile.c_str()); printf("%s\n", importer.GetErrorString()); return mesh; } mesh.mScene = importer.ReadFile( pFile, aiProcessPreset_TargetRealtime_Quality);//|aiProcess_FlipWindingOrder); // If the import failed, report it if( !mesh.mScene) { printf("%s\n", importer.GetErrorString()); return mesh; } // Now we can access the file's contents. printf("Import of scene %s succeeded.", pFile.c_str()); GetBoundingBox(mesh.mScene, &mesh.mBbMin, &mesh.mBbMax); aiVector3D diff = mesh.mBbMax-mesh.mBbMin; float w = std::max(diff.x, std::max(diff.y, diff.z)); mesh.mScaleFactor = 1.0f / w; BufferIndexedVerts(mesh); mesh.mNumIndices = mesh.mScene->mMeshes[0]->mNumFaces*3; return mesh; }
void Mesh::parseAI(const char* path){ Assimp::Importer importer; const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_JoinIdenticalVertices); skeleton = Skeleton(scene); if(!scene) { ERROR("Could not import file: " << path); ERROR("Reason: " << importer.GetErrorString()); exit(1); } debugNodes(scene->mRootNode, 0); const aiMesh* mesh = scene->mMeshes[0]; for(unsigned int v=0; v<mesh->mNumVertices; v++){ vertices.push_back(glm::vec3(mesh->mVertices[v][0], mesh->mVertices[v][1], mesh->mVertices[v][2])); } for(unsigned int n=0; n<mesh->mNumVertices; n++){ normals.push_back(glm::vec3(mesh->mNormals[n][0], mesh->mNormals[n][1], mesh->mNormals[n][2])); } for(unsigned int f=0; f<mesh->mNumFaces; f++){ aiFace face = mesh->mFaces[f]; if(face.mNumIndices != 3) { ERROR("NON-TRIANGULAR POLY"); } indeces.push_back(glm::uvec3(face.mIndices[0], face.mIndices[1], face.mIndices[2])); } for(unsigned int u=0; u<mesh->mNumVertices; u++){ uvs.push_back(glm::vec2(mesh->mTextureCoords[0][u].x, mesh->mTextureCoords[0][u].y)); } reset(); }
Mesh * LoadMesh(const char * filename) { // Create an instance of the Importer class Assimp::Importer importer; // And have it read the given file with some example postprocessing // Usually - if speed is not the most important aspect for you - you'll // propably to request more postprocessing than we do in this example. const aiScene* aiscene = importer.ReadFile( filename, aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_JoinIdenticalVertices | aiProcess_SortByPType); // If the import failed, report it if( !aiscene) { printf("%s \n", importer.GetErrorString()); return NULL; } aiMesh * aimesh; Mesh * mesh = new Mesh(); std::vector<vec3> vertex; std::vector<vec3> normal; std::vector<vec3> tangent; std::vector<vec2> texCoord; // Now we can access the file's contents. for(u32 i=0; i<aiscene->mNumMeshes(); ++i) { aimesh = aiscene->mMeshes[i]; if(aimesh->HasPositions()) { } } return mesh; }
int SceneLoader::LoadFile(const char* filename) { Assimp::Importer importer; const aiScene *scene = importer.ReadFile(filename, 0); scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace | aiProcess_MakeLeftHanded | aiProcess_FlipWindingOrder | aiProcess_JoinIdenticalVertices); if (!scene) { std::stringstream oss; oss << "ERROR - File: " << filename << " not found." << std::endl; std::string debugMsg(oss.str()); OutputDebugStringA(debugMsg.c_str()); return false; } DrawableObject *newObject = new DrawableObject(); std::vector<Vertex> vertexList; std::vector<UINT> indexList; std::stringstream oss; for (unsigned int i = 0; i < scene->mRootNode->mNumChildren; ++i) { bool successfulLoad = true; aiNode* currentNode = scene->mRootNode->mChildren[i]; BuildShaders(d3dDevice, *newObject, mShaderManager); for (unsigned int j = 0; j < currentNode->mNumMeshes; ++j) { ProcessMesh(d3dDevice, *scene->mMeshes[currentNode->mMeshes[j]], *newObject, vertexList, indexList, scene->mMeshes[currentNode->mMeshes[j]]->mMaterialIndex - 1); //LoadMaterials(d3dDevice, scene->mMeshes[currentNode->mMeshes[j]]->mMaterialIndex, *newObject, scene); oss << "MatIndex = " << scene->mMeshes[currentNode->mMeshes[j]]->mMaterialIndex << "\n"; } } std::string debugMsg(oss.str()); OutputDebugStringA(debugMsg.c_str()); for (unsigned int i = 0; i < scene->mNumMaterials; ++i) { LoadMaterials(d3dDevice, i, *newObject, scene); } newObject->GetMeshData()->Initialize(d3dDevice, vertexList, indexList); mDrawableObjects.push_back(newObject); return mDrawableObjects.size() - 1; }
// ------------------------------------------------------------------------------------------------ const aiScene* aiImportFileEx( const char* pFile, unsigned int pFlags, aiFileIO* pFS) { ai_assert(NULL != pFile); // create an Importer for this file Assimp::Importer* imp = new Assimp::Importer; // copy the global property lists to the Importer instance // (we are a friend of Importer) imp->pimpl->mIntProperties = gIntProperties; imp->pimpl->mFloatProperties = gFloatProperties; imp->pimpl->mStringProperties = gStringProperties; // setup a custom IO system if necessary if (pFS) { imp->SetIOHandler( new CIOSystemWrapper (pFS) ); } // and have it read the file const aiScene* scene = imp->ReadFile( pFile, pFlags); // if succeeded, place it in the collection of active processes if( scene) { #if (defined AI_C_THREADSAFE) boost::mutex::scoped_lock lock(gMutex); #endif gActiveImports[scene] = imp; } else { // if failed, extract error code and destroy the import gLastErrorString = imp->GetErrorString(); delete imp; } // return imported data. If the import failed the pointer is NULL anyways return scene; }
std::shared_ptr<Scene> SceneFactory::CreateFromFile(const std::string& filename) { Assimp::Importer importer; const aiScene* scene = importer.ReadFile(filename, aiProcess_Triangulate | aiProcess_GenNormals | aiProcess_ImproveCacheLocality | aiProcess_JoinIdenticalVertices | aiProcess_PreTransformVertices); if (scene == NULL) { std::printf("\nImport failed:\n\t"); auto errorString = importer.GetErrorString(); std::printf(errorString); std::printf("\n"); return nullptr; } Scene::vertexList vertices = GetVertices(scene); Scene::triangleList faces = GetFaces(scene); Scene::materialList materials = GetMaterials(scene); return std::shared_ptr<Scene>(new Scene(vertices, faces, materials)); }
std::shared_ptr<MeshData> RE::FileSystem::LoadModel(const std::wstring &filePath) { const std::string sFilePaths{ filePath.begin(), filePath.end() }; Assimp::Importer importer; const aiScene *scene = importer.ReadFile(sFilePaths, aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_JoinIdenticalVertices | aiProcess_SortByPType | aiProcess_ConvertToLeftHanded | aiProcess_FixInfacingNormals ); if (!scene) { Log::Get().Write(std::string("[FileSystem] Assimp importer could not read mesh file:") + importer.GetErrorString()); } return std::make_shared<MeshData>(ProcessAssimpScene(scene->mRootNode, scene)); }
void Mesh::Load() { Clear(); Assimp::Importer importer; const aiScene* scene = importer.ReadFile(sFilepath.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs); if(scene) { InitMesh(scene, sFilepath); } else { std::cout << "Cannot find " << sFilepath << " " << importer.GetErrorString() << std::endl; //throw std::runtime_error(std::string("Error Parsing: ") + sFilepath + //std::string("\n") + importer.GetErrorString()); } }
// ------------------------------------------------------------------------------------------------ // Returns the error text of the last failed import process. aiBool aiIsExtensionSupported(const char* szExtension) { ai_assert(NULL != szExtension); aiBool candoit=AI_FALSE; ASSIMP_BEGIN_EXCEPTION_REGION(); #ifdef AI_C_THREADSAFE boost::mutex::scoped_lock lock(gMutex); #endif if (!gActiveImports.empty()) { return ((*(gActiveImports.begin())).second->IsExtensionSupported( szExtension )) ? AI_TRUE : AI_FALSE; } // fixme: no need to create a temporary Importer instance just for that .. Assimp::Importer tmp; candoit = tmp.IsExtensionSupported(std::string(szExtension)) ? AI_TRUE : AI_FALSE; ASSIMP_END_EXCEPTION_REGION(aiBool); return candoit; }
const std::vector<Mesh> & Mesh::loadModel(const std::string & modelName) { static std::unordered_map<std::string, std::vector<Mesh>> meshMap; if (meshMap.count(modelName) == 0) { Assimp::Importer importer; auto scene = importer.ReadFile(modelName, aiProcess_GenNormals | aiProcess_JoinIdenticalVertices | aiProcess_Triangulate | aiProcess_ImproveCacheLocality | aiProcess_RemoveRedundantMaterials | aiProcess_FlipUVs/* | aiProcess_RemoveComponent*/); if (!scene) { throw std::runtime_error("Could not load model: " + modelName); } std::vector<Mesh> meshData; loadMesh(modelName, meshData, scene->mRootNode, scene); meshMap.emplace(modelName, std::move(meshData)); } return meshMap[modelName]; }
sceneLoader::sceneLoader(const char* filename) { Assimp::Importer importer; //Initialize DevIL initDevIL(); const aiScene* scene=importer.ReadFile(filename, aiProcess_GenSmoothNormals| aiProcess_Triangulate| aiProcess_CalcTangentSpace| aiProcess_FlipUVs); if(scene->mFlags==AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { fprintf( stderr, "Couldn't load model, Error Importing Asset" ); return; } recursiveProcess(scene->mRootNode, scene); }
bool Mesh::LoadMesh(const std::string& Filename) { // Release the previously loaded mesh (if it exists) Clear(); bool Ret = false; Assimp::Importer Importer; const aiScene* pScene = Importer.ReadFile(Filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); if (pScene) { Ret = InitFromScene(pScene, Filename); } else { printf("Error parsing '%s': '%s'\n", Filename.c_str(), Importer.GetErrorString()); } return Ret; }
void Model::loadModel(std::string path) { Assimp::Importer import; //http://assimp.sourceforge.net/lib_html/postprocess_8h.html //aiProcess_GenNormals //aiProcess_GenSmoothNormals // triangulate flip uv y avoid duplicate verts make norms if not make bitangent and tangent const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_JoinIdenticalVertices | aiProcess_GenNormals | aiProcess_CalcTangentSpace); if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { std::string str = "ASSIMP ERROR: \""; str += path; str += "\" NOT LOADED;"; Logger::Log(str); return; } int foundSlash = 0; int foundDot = path.size()-1; for (int i = 0; i != path.size() - 1; ++i) { if (path[i] == '/' || path[i] == '\\') foundSlash = i+1; if (path[i] == '.') foundDot = i; } fileName = ""; for (int i = foundSlash; i != foundDot; ++i) { fileName += path[i]; } this->directory = path.substr(0, path.find_last_of('/')); this->processNode(scene->mRootNode, scene); std::string str = "Model ASSIMP: \""; str += path; str += "\" LOADED;"; Logger::Log(str); }
Resource* ResourceManager::LoadMesh(std::string filepath) { Assimp::Importer importer; const aiScene* scene = importer.ReadFile(filepath, aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_JoinIdenticalVertices | aiProcess_SortByPType); // NOTE: Depending on what ReadFile returns, this may not work as intended if (!scene) { #if DEBUG Debug::LogError("[ResourceManager] Assimp importer could not read file."); #endif return 0; } MeshData data = AssimpProcessScene(scene->mRootNode, scene); Mesh* mesh = new Mesh(data); mesh->IncreaseReferenceCount(); resourceCollection[filepath] = mesh; return dynamic_cast<Resource*>(mesh); }
bool ModelLoader::Load( std::string filename, Vertex::VERTEX_TYPE type ) { // reset extents minX = minY = minZ = FLT_MAX; maxX = maxY = maxZ = FLT_MIN; Assimp::Importer importer; std::string file = modelDir+filename; Assimp::DefaultLogger::get()->info( "Importing: "+file ); scene = importer.ReadFile( file, //aiProcess_CalcTangentSpace| aiProcess_ImproveCacheLocality| //aiProcess_MakeLeftHanded| aiProcess_FlipWindingOrder| aiProcess_Triangulate| //aiProcess_JoinIdenticalVertices| aiProcess_SortByPType| aiProcess_FlipUVs ); if( !scene ) { Assimp::DefaultLogger::get()->error( importer.GetErrorString() ); return false; } if( !scene->HasMeshes() ) { Assimp::DefaultLogger::get()->error( "File contains no mesh" ); return false; } aiMesh* sceneMesh = scene->mMeshes[0]; CreateVertexBuffer( sceneMesh, type ); CreateIndexBuffer( sceneMesh->mFaces, sceneMesh->mNumFaces ); if( scene->HasAnimations() ) { CreateSkeleton( sceneMesh->mBones, sceneMesh->mNumBones ); CreateBoneHierarchy(); CreateAnimations(); } return true; }
bool Mesh::LoadMesh(const std::string& Filename) { Clear(); bool Ret = false; Assimp::Importer Importer; const aiScene* pScene = Importer.ReadFile(Filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals| aiProcess_FlipUVs); if (pScene){ Ret = InitFromScene(pScene, Filename); } else { printf("Error parsing '%s': '%s'\n", Filename.c_str(), Importer.GetErrorString()); } return Ret; }
void Model::loadModel(string path) { Assimp::Importer importer; /* aiProcess_FlipUVs: 基于y轴翻转纹理坐标(前面的教程中有) aiProcess_Triangulate: 如果模型不是(全部)由三角形组成,应该转换所有的模型的原始几何形状为三角形。 aiProcess_GenNormals: 如果模型没有包含法线向量,就为每个顶点创建法线。 aiProcess_SplitLargeMeshes: 把大的网格成几个小的的下级网格,当你渲染有一个最大数量顶点的限制时或者只能处理小块网格时很有用。 aiProcess_OptimizeMeshes: 和上个选项相反,它把几个网格结合为一个更大的网格。以减少绘制函数调用的次数的方式来优化。 */ const aiScene* scene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); if (!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { cout << "ERROR::ASSIMP::" << importer.GetErrorString() << endl; return; } this->directory = path.substr(0, path.find_last_of('/')) + "/"; this->processNode(scene->mRootNode, scene); }
int ModelImpAI::ReadFile(const std::string& file_path) { Assimp::Importer importer; const aiScene* scene = importer.ReadFile( file_path, aiProcess_CalcTangentSpace | aiProcess_Triangulate | aiProcess_JoinIdenticalVertices ); assert(scene->mNumMeshes == 1); //only deals with one mesh per file(scene) for now aiMesh* mesh = scene->mMeshes[0]; assert(mesh->HasNormals()); //assert for normals assert(mesh->HasTextureCoords(0)); //assert for texture coordinates for(int i=0; i<mesh->mNumFaces; i++) { const aiFace* face = &mesh->mFaces[i]; assert(face->mNumIndices == 3); Triangle* t = new Triangle; for(int j=0; j<face->mNumIndices; j++) { int index = face->mIndices[j]; t->vertices[j][0] = mesh->mVertices[index].x; t->vertices[j][1] = mesh->mVertices[index].y; t->vertices[j][2] = mesh->mVertices[index].z; t->normals[j][0] = mesh->mNormals[index].x; t->normals[j][1] = mesh->mNormals[index].y; t->normals[j][2] = mesh->mNormals[index].z; t->uvs[j][0] = mesh->mTextureCoords[0][index].x; t->uvs[j][1] = mesh->mTextureCoords[0][index].y; } triangles_.push_back(t); } return 1; }
TEST_F(utObjImportExport, homogeneous_coordinates_Test) { static const std::string ObjModel = "v -0.500000 0.000000 0.400000 0.50000\n" "v -0.500000 0.000000 -0.800000 1.00000\n" "v 0.500000 1.000000 -0.800000 0.5000\n" "f 1 2 3\nB"; Assimp::Importer myimporter; const aiScene *scene = myimporter.ReadFileFromMemory(ObjModel.c_str(), ObjModel.size(), aiProcess_ValidateDataStructure); EXPECT_NE(nullptr, scene); EXPECT_EQ(scene->mNumMeshes, 1U); const aiMesh *mesh = scene->mMeshes[0]; EXPECT_EQ(mesh->mNumVertices, 3U); EXPECT_EQ(mesh->mNumFaces, 1U); const aiFace face = mesh->mFaces[0]; EXPECT_EQ(face.mNumIndices, 3U); const aiVector3D vertice = mesh->mVertices[0]; EXPECT_EQ(vertice.x, -1.0f); EXPECT_EQ(vertice.y, 0.0f); EXPECT_EQ(vertice.z, 0.8f); }
Apsis::Model::Thing::Thing(const char* path) { Assimp::Importer Importer; const aiScene* pScene = Importer.ReadFile(path, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs); if (pScene == NULL) { throw "Cannot load 3d object. No suitable importer."; } unsigned int numberOfMeshes = pScene->mNumMeshes; unsigned int numberOfMaterials = pScene->mNumMaterials; for (unsigned int i = 0; i < numberOfMeshes; i++) { _addMesh(pScene->mMeshes[i]); } for (unsigned int i = 0; i < numberOfMaterials; i++) { _addMaterial(pScene->mMaterials[i]); } }
void HKWindow::addSourceModelsTriggered() { Assimp::Importer importer; std::string extensions_assimp = ""; importer.GetExtensionList(extensions_assimp); QStringList extensions= QString(extensions_assimp.c_str()).split(";"); extensions.removeOne("*"); // Build Extensions String for Open Dialog QString extensions_str = "All supported formats ("; foreach(QString extension, extensions) extensions_str += extension + " "; extensions_str += ");;"; // Specific filters foreach(QString extension, extensions) { size_t index = importer.GetImporterIndex(extension.toStdString().c_str()); if (index != -1) { const aiImporterDesc *description = importer.GetImporterInfo(index); extensions_str += QString("%1 (%2);;").arg(description->mName).arg(extension); } }
void vModel::loadModel(const char* modelFile) { Assimp::Importer importer; //aiProcessPreset_TargetRealtime_Fast has the configs you'll need const aiScene *scene = importer.ReadFile(modelFile, aiProcessPreset_TargetRealtime_Fast); //assuming you only want the first mesh aiMesh *mesh = scene->mMeshes[0]; numVerts = mesh->mNumFaces*3; vertexArray = new float[mesh->mNumFaces*3*3]; normalArray = new float[mesh->mNumFaces*3*3]; uvArray = new float[mesh->mNumFaces*3*2]; for(unsigned int i=0;i<mesh->mNumFaces;i++) { const aiFace& face = mesh->mFaces[i]; for(int j=0;j<3;j++) { aiVector3D uv = mesh->mTextureCoords[0][face.mIndices[j]]; memcpy(uvArray,&uv,sizeof(float)*2); uvArray+=2; aiVector3D normal = mesh->mNormals[face.mIndices[j]]; memcpy(normalArray,&normal,sizeof(float)*3); normalArray+=3; aiVector3D pos = mesh->mVertices[face.mIndices[j]]; memcpy(vertexArray,&pos,sizeof(float)*3); vertexArray+=3; } } uvArray-=mesh->mNumFaces*3*2; normalArray-=mesh->mNumFaces*3*3; vertexArray-=mesh->mNumFaces*3*3; }
bool BasicMesh::LoadMesh(const std::string & filename) { // Release the previously loaded mesh (if it exists) Clear(); // Create the VAO glGenVertexArrays(1, &m_VAO); glBindVertexArray(m_VAO); // Create the buffers for the vertices attributes glGenBuffers(2, m_Buffers); bool Ret = false; Assimp::Importer Importer; const aiScene* pScene = Importer.ReadFile(filename.c_str(), aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_FindDegenerates | aiProcess_CalcTangentSpace); if (pScene) { Ret = InitFromScene(pScene); } else { printf("Error parsing '%s': '%s'\n", filename.c_str(), Importer.GetErrorString()); } // Make sure the VAO is not changed from the outside glBindVertexArray(0); //// can delete the damn buffers alr if (m_Buffers[0] != 0) { glDeleteBuffers(sizeof(m_Buffers) / sizeof(m_Buffers[0]), m_Buffers); } return false; }
// No VAO Created bool GLModel::LoadVertexData() { //Clear for(size_t i=0; i<this->positions->size(); i++) { this->positions->at(i).clear(); this->normals->at(i).clear(); } for(size_t i=0; i<this->faces->size(); i++) this->faces->at(i).clear(); Assimp::Importer Importer; const aiScene* scene = Importer.ReadFile(filename, aiProcess_Triangulate | aiProcess_GenSmoothNormals | aiProcess_FlipUVs | aiProcess_JoinIdenticalVertices); if (scene) { this->faces->resize(scene->mNumMeshes); this->positions->resize(scene->mNumMeshes); for(unsigned int i=0; i<scene->mNumMeshes; i++) { const aiMesh* mesh = scene->mMeshes[i]; this->AddVertexData(mesh, i); } return true; } else { std::cerr << "[E] Could not load " << filename << std::endl; std::cerr << Importer.GetErrorString() << std::endl; } return false; }
void GameObj::load_model(string path){ if(loaded_meshes.count(path) > 0){ //We have already loaded this model meshes = loaded_meshes[path]; return; } Assimp::Importer import; const aiScene* scene = import.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs); if(!scene || scene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !scene->mRootNode) { cout << "Error::ASSIMP::" << import.GetErrorString() << endl; return; } mesh_dir = path.substr(0, path.find_last_of('/')); process_node(scene->mRootNode, scene); //Store the loaded meshes for use in other objects loaded_meshes[path] = meshes; }