Attempting to load wavefront obj files with multiple -o groupings into 1 set of VAO using OpenGL

[JordanLiao]

The obj files I am trying to load have multiple -o flags, so there are multiple meshes. I am trying to load them with only 1 VAO, and I will draw them by recording each mesh's offset and size. However, it seems only the first mesh is drawn correctly, and the rest of the meshes are all distorted some how.
This is my loading logic:
`Object* ResourceManager::loadObject(const char* fPath) {
std::string pathName = std::string(fPath);
std::string objName = std::string(getFileNameFromPath(pathName));

// if this object was loaded previously
if (objMap.find(objName) != objMap.end())
	return objMap[objName];

Assimp::Importer imp;
const aiScene* pScene = imp.ReadFile(fPath, aiProcess_Triangulate | aiProcess_PreTransformVertices | 
	aiProcess_JoinIdenticalVertices);
//const aiScene* pScene = imp.ReadFile(fPath, aiProcess_Triangulate | aiProcess_PreTransformVertices
	//| aiProcess_GenSmoothNormals | aiProcess_JoinIdenticalVertices | aiProcess_FlipWindingOrder);
if (pScene == nullptr) {
	printf("Error parsing '%s': '%s'\n", fPath, imp.GetErrorString());
	return nullptr;
}

Object* obj = new Object(objName);
// Initialize the meshes in the obj file one by one
std::vector<GLfloat> vert, norm, text;
std::vector<GLuint> indices;
int vertexOffset = 0;
std::cout << objName << " numMeshes: " << pScene->mNumMeshes << std::endl;
for (unsigned int i = 0; i < pScene->mNumMeshes; i++) {
	std::cout << objName << ": vOffset " << vertexOffset << " numV "<< pScene->mMeshes[i]->mNumFaces*3 << std::endl;
	aiMesh* pMesh = pScene->mMeshes[i];
	aiVector3D Zero3D(0.0f, 0.0f, 0.0f);
	for (unsigned int j = 0; j < pMesh->mNumVertices; j++) {
		vert.push_back(pMesh->mVertices[j].x); vert.push_back(pMesh->mVertices[j].y); vert.push_back(pMesh->mVertices[j].z);
		norm.push_back(pMesh->mNormals[j].x); norm.push_back(pMesh->mNormals[j].y); norm.push_back(pMesh->mNormals[j].z);
		aiVector3D textCoord = pMesh->HasTextureCoords(0) ? pMesh->mTextureCoords[0][j] : Zero3D;
		text.push_back(textCoord.x); text.push_back(textCoord.y);
	}

	for (unsigned int j = 0; j < pMesh->mNumFaces; j++) {
		aiFace face = pMesh->mFaces[j];
		indices.push_back(face.mIndices[0]); 
		indices.push_back(face.mIndices[1]); 
		indices.push_back(face.mIndices[2]);
	}

	aiMaterial* mtl = pScene->mMaterials[pMesh->mMaterialIndex];
	std::string meshName = std::string(pMesh->mName.C_Str());
	Mesh* mesh = new Mesh(meshName, loadMaterial(mtl), vertexOffset, pMesh->mNumFaces * 3);
	obj->meshList.push_back(mesh);
	vertexOffset = vertexOffset + 3 * pMesh->mNumFaces;
}

//create the obj's node structure
//obj->root = processNode(pScene->mRootNode, obj->meshList);

//send the data to the gpu
GLuint vao;
glcheck(glGenVertexArrays(1, &vao));
obj->vao = vao; //shared vao variable

GLuint vbo[3];
GLuint ebo;

glcheck(glBindVertexArray(vao));
glcheck(glGenBuffers(3, vbo));

glcheck(glBindBuffer(GL_ARRAY_BUFFER, vbo[0]));
glcheck(glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * vert.size(), vert.data(), GL_STATIC_DRAW));
glcheck(glEnableVertexAttribArray(0));
glcheck(glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0));

glcheck(glBindBuffer(GL_ARRAY_BUFFER, vbo[1]));
glcheck(glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * norm.size(), norm.data(), GL_STATIC_DRAW));
glcheck(glEnableVertexAttribArray(1));
glcheck(glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0));

glcheck(glBindBuffer(GL_ARRAY_BUFFER, vbo[2]));
glcheck(glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * text.size(), text.data(), GL_STATIC_DRAW));
glcheck(glEnableVertexAttribArray(2));
glcheck(glVertexAttribPointer(2, 2, GL_FLOAT, GL_FALSE, 0, 0));

glcheck(glGenBuffers(1, &ebo));
glcheck(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ebo));
glcheck(glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * indices.size(), indices.data(), GL_STATIC_DRAW));

// Unbind the VBO/VAO
glcheck(glBindVertexArray(0));
glcheck(glBindBuffer(GL_ARRAY_BUFFER, 0));
glcheck(glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0));

objMap[objName] = obj;
objList.push_back(obj);

return obj;}`

and this is my drawing logic:
for (int i = 0; i < instObj->meshList.size(); i++) { Mesh* mesh = instObj->meshList[i]; glcheck(glDrawElements(GL_TRIANGLES, mesh->size, GL_UNSIGNED_INT, (GLvoid*)(sizeof(GLuint) * mesh->vertexOffset))); }

Any help would be welcomed, Thanks guys.