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; }
ScenePtr ModelLoader::loadScene(const std::string & path) { //Création de la scène ScenePtr scene(new Scene); SceneObjectPtr &rootObject = scene->getRootObject(); //Chargement du modèle dans assimp Assimp::Importer importer; const aiScene *aiScene = importer.ReadFile(path, aiProcess_Triangulate | aiProcess_FlipUVs | aiProcess_CalcTangentSpace); if (!aiScene) { throw std::runtime_error(importer.GetErrorString()); } importer.ApplyPostProcessing(aiProcess_GenNormals); if (!aiScene || aiScene->mFlags == AI_SCENE_FLAGS_INCOMPLETE || !aiScene->mRootNode) { cout << "ERROR::ASSIMP::" << importer.GetErrorString() << endl; return ScenePtr(nullptr); } m_directory = path.substr(0, path.find_last_of('/')); processNode(aiScene, scene, aiScene->mRootNode, rootObject, glm::mat4()); importer.FreeScene(); return std::move(scene); }
MeshPtr Helper::loadMesh(std::string path){ MeshPtr res = nullptr; Assimp::Importer importer; const aiScene* scene = importer.ReadFile(path.c_str(),aiProcess_Triangulate|aiProcess_GenSmoothNormals|aiProcess_GenUVCoords|aiProcess_CalcTangentSpace); scene = importer.ApplyPostProcessing(aiProcess_CalcTangentSpace); if(!scene){ cout<<"ERROR LOADING MESH: "<<path<<endl; return nullptr; } for(int i=0;i<scene->mNumMeshes;i++){ GeometryPtr meshGEO = GeometryPtr(new Geometry()); MaterialPtr meshMAT = MaterialPtr(new Material()); const aiMesh* mesh = scene->mMeshes[i]; const aiVector3D Zero3D(0.0f,0.0f,0.0f); const aiColor4D EmptyColor(0.0f,0.0f,0.0f,0.0f); for(unsigned int i=0;i<mesh->mNumVertices;i++){ const aiVector3D* pPos = &(mesh->mVertices[i]); const aiVector3D* pNormal = mesh->HasNormals()? &(mesh->mNormals[i]):&Zero3D; const aiColor4D* pColor =mesh->HasVertexColors(0)? (mesh->mColors[i]):&EmptyColor; const aiVector3D* pTexCoord = mesh->HasTextureCoords(0)? &(mesh->mTextureCoords[0][i]):&Zero3D; const aiVector3D* pTangent = mesh->HasTangentsAndBitangents()? &(mesh->mTangents[i]):&Zero3D; cout<<pTangent->x<<" | "<<pTangent->y<<" | "<<pTangent->z<<endl; glm::vec3 pos = glm::vec3(pPos->x,pPos->y,pPos->z); glm::vec3 norm = glm::vec3(pNormal->x,pNormal->y,pNormal->z); glm::vec3 col = glm::vec3(pColor->r,pColor->g,pColor->b); glm::vec2 tex = glm::vec2(pTexCoord->x,pTexCoord->y); glm::vec3 tan = glm::vec3(pTangent->x,pTangent->y,pTangent->z); meshGEO->pushVertex(Vertex(pos,col,tex,norm,tan)); } for(unsigned int i=0;i<mesh->mNumFaces;i++){ const aiFace& face = mesh->mFaces[i]; meshGEO->pushFace(face.mIndices[0],face.mIndices[1],face.mIndices[2]); } string Dir = Helper::getDirectory(path); aiString texPath; if(AI_SUCCESS == scene->mMaterials[mesh->mMaterialIndex]->GetTexture(aiTextureType_DIFFUSE,0,&texPath)){ meshMAT->diffuse = TexturePtr(new Texture(Dir+texPath.data,0)); } if(AI_SUCCESS == scene->mMaterials[mesh->mMaterialIndex]->GetTexture(aiTextureType_HEIGHT,0,&texPath)){ meshMAT->normal = TexturePtr(new Texture(Dir+texPath.data,0)); } if(res == nullptr){ res = MeshPtr(new Mesh(meshGEO,meshMAT)); }else{ res->addSubMesh(MeshPtr(new Mesh(meshGEO,meshMAT))); } } return res; }
bool StaticMesh::loadFromFile(const std::string& infile) { Assimp::Importer imp; // Load scene and grab first mesh only imp.SetPropertyInteger(AI_CONFIG_PP_SBP_REMOVE, aiPrimitiveType_LINE | aiPrimitiveType_POINT | aiPrimitiveType_POLYGON, nullptr); #ifdef DEBUG std::cout << "Calling Assimp::Importer::ReadFile...\n"; #endif // DEBUG const aiScene *scene = imp.ReadFile(infile, aiProcessPreset_TargetRealtime_Quality & (!aiProcess_SplitLargeMeshes)); #ifdef DEBUG std::cout << "Checking for a mesh...\n"; #endif // DEBUG if(scene == nullptr) return false; else if(!scene->HasMeshes()) return false; imp.ApplyPostProcessing(aiProcess_JoinIdenticalVertices); // Will only load one mesh const aiMesh *mesh = scene->mMeshes[0]; #ifdef DEBUG std::cout << "Checking mesh has what we need...\n"; #endif // DEBUG // Don't process special mesh types if(!mesh->HasPositions() || !mesh->HasFaces()) return false; vertexCount = mesh->mNumVertices; triangleCount = mesh->mNumFaces; // Check what attributes are in the mesh and // calculate total count of floats std::size_t componentCount = components.vertex = 3; if(mesh->HasNormals()) { componentCount += components.normal = 3; #ifdef DEBUG std::cout << "Has normals\n"; #endif // DEBUG } if(mesh->HasTangentsAndBitangents()) { componentCount += (components.tangentBitangent = 3) * 2; #ifdef DEBUG std::cout << "Has tangents and bitangents\n"; #endif // DEBUG } if(mesh->HasTextureCoords(0)) { componentCount += components.texture = 3; #ifdef DEBUG std::cout << "Has texture coordinates\n"; #endif // DEBUG } // Scale size for size of float std::size_t totalSize = componentCount * sizeof(float) * vertexCount; #ifdef DEBUG std::cout << totalSize << std::endl; std::cout << "Allocating and mapping vertex buffer...\n"; #endif // DEBUG // Set size and map buffer glBindBuffer(GL_ARRAY_BUFFER, buffer); glBufferData(GL_ARRAY_BUFFER, totalSize, nullptr, GL_STATIC_DRAW); GLfloat *mapPtr = (GLfloat*) glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY); // glNamedBufferDataEXT(buffer, totalSize, nullptr, GL_STATIC_DRAW); // GLfloat *mapPtr = (GLfloat*) glMapNamedBufferEXT(buffer, GL_WRITE_ONLY); if(mapPtr == nullptr) return false; #ifdef DEBUG std::cout << "Worked!\n"; #endif // DEBUG // Load all attributes into mapped buffer for(unsigned int i = 0; i < vertexCount; ++i) { GLfloat *head = mapPtr + i * componentCount; *head++ = mesh->mVertices[i].x; *head++ = mesh->mVertices[i].y; *head++ = mesh->mVertices[i].z; if(mesh->HasNormals()) { *head++ = mesh->mNormals[i].x; *head++ = mesh->mNormals[i].y; *head++ = mesh->mNormals[i].z; } if(mesh->HasTextureCoords(0)) { *head++ = mesh->mTextureCoords[0][i].x; *head++ = mesh->mTextureCoords[0][i].y; *head++ = mesh->mTextureCoords[0][i].z; } if(mesh->HasTangentsAndBitangents()) { *head++ = mesh->mTangents[i].x; *head++ = mesh->mTangents[i].y; *head++ = mesh->mTangents[i].z; *head++ = mesh->mBitangents[i].x; *head++ = mesh->mBitangents[i].y; *head++ = mesh->mBitangents[i].z; } } if(!glUnmapBuffer(GL_ARRAY_BUFFER)) return false; #ifdef DEBUG std::cout << "Allocating and mapping index buffer...\n"; #endif // DEBUG // Same for index buffer glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices); glBufferData(GL_ELEMENT_ARRAY_BUFFER, triangleCount*3*sizeof(GLshort), nullptr, GL_STATIC_DRAW); GLushort *indexMapPtr = (GLushort*) glMapBuffer(GL_ELEMENT_ARRAY_BUFFER, GL_WRITE_ONLY); // glNamedBufferDataEXT(indices, triangleCount * 3 * sizeof(GLushort), nullptr, GL_STATIC_DRAW); // GLushort *indexMapPtr = (GLushort*) glMapNamedBufferEXT(indices, GL_WRITE_ONLY); if(indexMapPtr == nullptr) return false; #ifdef DEBUG std::cout << "Worked!\n"; #endif // DEBUG for(unsigned int i = 0; i < triangleCount; ++i) { #ifdef DEBUG assert(mesh->mFaces[i].mNumIndices == 3); #endif // DEBUG unsigned int *indexArray = mesh->mFaces[i].mIndices; for(unsigned int j = 0; j < 3; ++j) { #ifdef DEBUG assert(*indexArray <= std::numeric_limits<GLushort>::max()); #endif // DEBUG *indexMapPtr++ = *indexArray++; } } if(!glUnmapBuffer(GL_ELEMENT_ARRAY_BUFFER)) return false;; #ifdef DEBUG std::cout << "Loading mesh successful!\n"; std::cout << "Setting up vertex array...\n"; #endif // DEBUG glBindVertexArray(vertexArray); glBindVertexBuffer(0, buffer, 0, (components.vertex + components.normal + components.texture + components.tangentBitangent * 2) * sizeof(GLfloat)); glVertexAttribFormat(0, 3, GL_FLOAT, GL_FALSE, 0); glVertexAttribBinding(0, 0); glEnableVertexAttribArray(0); if(components.normal) { glVertexAttribFormat(1, 3, GL_FLOAT, GL_FALSE, components.vertex * sizeof(float)); glVertexAttribBinding(1, 0); glEnableVertexAttribArray(1); } if(components.texture) { glVertexAttribFormat(2, 3, GL_FLOAT, GL_FALSE, (components.vertex + components.normal) * sizeof(float)); glVertexAttribBinding(2, 0); glEnableVertexAttribArray(2); } if(components.tangentBitangent) { glVertexAttribFormat(3, 3, GL_FLOAT, GL_FALSE, (components.vertex + components.normal + components.texture) * sizeof(float)); glVertexAttribBinding(3, 0); glEnableVertexAttribArray(3); glVertexAttribFormat(4, 3, GL_FLOAT, GL_FALSE, (components.vertex + components.normal + components.texture + components.tangentBitangent) * sizeof(float)); glVertexAttribBinding(4, 0); glEnableVertexAttribArray(4); } glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, indices); glBindVertexArray(0); #ifdef DEBUG std::cout << vertexCount << ' ' << triangleCount << std::endl; std::cout << +components.vertex << ' '; std::cout << +components.normal << ' '; std::cout << +components.texture << ' '; std::cout << +components.tangentBitangent << std::endl; #endif // DEBUG return true; }