Part of the Khronos Group
OpenGL.org

The Industry's Foundation for High Performance Graphics

from games to virtual reality, mobile phones to supercomputers

Results 1 to 3 of 3

Thread: Parsing an OBJ file to add triangles to a Bullet Physics Triangle Mesh

  1. #1
    Newbie Newbie
    Join Date
    May 2018
    Posts
    2

    Unhappy Parsing an OBJ file to add triangles to a Bullet Physics Triangle Mesh

    So I have created a 3D maze in blender and have successfully loaded the object into opengl and drawn it. I read through the OBJ file that was exported and extracted all the needed information.

    After I load the object in and draw it I try to read back through the file and add the vertices of each triangle into the Bullet Triangle Mesh to handle the collision for me. I am able to load the information but I'm getting collisions where I should not be getting collision. Essentially I am not loading the triangle information to the mesh correctly, I believe.

    Here is what I have for my file parser so far. I edited it from the file parser that loads the object and draws for OpenGL.
    Code :
    bool ObjModel::reloadVertices(std::string path, std::string filename){
     
        std::vector<unsigned int> vertexIndices, texIndices, normalIndices;
        std::vector<glm::vec3> file_vertices;
        std::vector<glm::vec2> file_texcoords;
        std::vector<glm::vec3> file_normals;
     
        std::string nextmatname = "";
        std::string matname = "";
        bool firstfaceset = true;
     
        std::string fullFilename = path + filename;
     
        FILE * file = fopen(fullFilename.c_str(), "r");
     
        if(file == NULL)
        {
            std::cout << "Cannot open file: " << filename << std::endl;
            return false;
        }
     
        vertices.clear();
        texcoords.clear();
        normals.clear();
     
        bool finished = false;
        while(!finished)
        {
            char lineHeader[512];
     
            int res = fscanf(file, "%s", lineHeader);
            if (res == EOF)
            {
                finished = true;
            }
            else
            {
                if (strcmp(lineHeader, "mtllib") == 0)
                {
                    char MaterialFilename[4096];
                    fscanf(file, "%s", MaterialFilename);
                    std::string matfile = MaterialFilename;
     
                    LoadMateials(path, matfile);
                }
                else if (strcmp(lineHeader, "usemtl") == 0)
                {
                    matname = nextmatname;
                    char MaterialName[4096];
                    fscanf(file, "%s", MaterialName);
                    nextmatname = MaterialName;
     
                    if (firstfaceset)
                    {
                        firstfaceset = false;
                    }
                    else
                    {
                        for(unsigned int i = 0; i < vertexIndices.size(); i++)
                        {
                            unsigned int vertexIndex = vertexIndices[i];
                            glm::vec3 vertex = file_vertices[vertexIndex - 1];
                            vertices.push_back(vertex);
                        }
     
                        for(unsigned int i = 0; i < normalIndices.size(); i++)
                        {
                            unsigned int normalIndex = normalIndices[i];
                            glm::vec3 normal = file_normals[normalIndex - 1];
                            normals.push_back(normal);
                        }
     
                        for(unsigned int i = 0; i < texIndices.size(); i++)
                        {
                            unsigned int texIndex = texIndices[i];
                            glm::vec2 texcoord = file_texcoords[texIndex - 1];
                            texcoords.push_back(texcoord);
                        }
     
                        LoadDataToGraphicsCard(matname);
     
                        //vertexIndices.clear();
                        texIndices.clear();
                        normalIndices.clear();
                        //vertices.clear();
                        texcoords.clear();
                        normals.clear();
                    }
                }
                else if (strcmp(lineHeader, "v") == 0)
                {
                    glm::vec3 vertex;
                    fscanf(file, "%f %f %f\n", &vertex.x, &vertex.y, &vertex.z);
                    file_vertices.push_back(vertex);
                }
                else if (strcmp(lineHeader, "vt") == 0)
                {
                    glm::vec2 tex;
                    fscanf(file, "%f %f\n", &tex.x, &tex.y);
                    file_texcoords.push_back(tex);
                }
                else if (strcmp(lineHeader, "vn") == 0)
                {
                    glm::vec3 normal;
                    fscanf(file, "%f %f %f\n", &normal.x, &normal.y, &normal.z);
                    file_normals.push_back(normal);
                }
                else if (strcmp(lineHeader, "f") == 0)
                {
                    unsigned int vertexIndex[3], uvIndex[3], normalIndex[3];
     
                    vertexIndex[0] = 1;
                    vertexIndex[1] = 1;
                    vertexIndex[2] = 1;
                    uvIndex[0] = 1;
                    uvIndex[1] = 1;
                    uvIndex[2] = 1;
                    normalIndex[0] = 1;
                    normalIndex[1] = 1;
                    normalIndex[2] = 1;
     
                    long filepos = ftell(file);
                    int matches = fscanf(file, "%d/%d/%d %d/%d/%d %d/%d/%d\n", &vertexIndex[0], &uvIndex[0], &normalIndex[0], &vertexIndex[1], &uvIndex[1], &normalIndex[1], &vertexIndex[2], &uvIndex[2], &normalIndex[2]);
                    if (matches == 9)
                    {
                        vertexIndices.push_back(vertexIndex[0]);
                        vertexIndices.push_back(vertexIndex[1]);
                        vertexIndices.push_back(vertexIndex[2]);
                        //texIndices.push_back(uvIndex[0]);
                        //texIndices.push_back(uvIndex[1]);
                        //texIndices.push_back(uvIndex[2]);
                        //normalIndices.push_back(normalIndex[0]);
                        //normalIndices.push_back(normalIndex[1]);
                        //normalIndices.push_back(normalIndex[2]);
                    }
                    else
                    {
                        fseek(file, filepos, SEEK_SET);
                        matches = fscanf(file, "%d//%d %d//%d %d//%d\n", &vertexIndex[0], &normalIndex[0], &vertexIndex[1], &normalIndex[1], &vertexIndex[2], &normalIndex[2]);
                        if (matches == 6)
                        {
                            vertexIndices.push_back(vertexIndex[0]);
                            vertexIndices.push_back(vertexIndex[1]);
                            vertexIndices.push_back(vertexIndex[2]);
                            //normalIndices.push_back(normalIndex[0]);
                            //normalIndices.push_back(normalIndex[1]);
                            //normalIndices.push_back(normalIndex[2]);
                        }
                        else
                        {
                            fseek(file, filepos, SEEK_SET);
                            matches = fscanf(file, "%d/%d %d/%d %d/%d\n", &vertexIndex[0], &uvIndex[0], &vertexIndex[1], &uvIndex[1], &vertexIndex[2], &uvIndex[2]);
                            if (matches == 6)
                            {
                                vertexIndices.push_back(vertexIndex[0]);
                                vertexIndices.push_back(vertexIndex[1]);
                                vertexIndices.push_back(vertexIndex[2]);
                                //texIndices.push_back(uvIndex[0]);
                                //texIndices.push_back(uvIndex[1]);
                                //texIndices.push_back(uvIndex[2]);
                            }
                            else
                            {
                                fseek(file, filepos, SEEK_SET);
                                matches = fscanf(file, "%d %d %d\n", &vertexIndex[0], &vertexIndex[1], &vertexIndex[2]);
                                if (matches == 3)
                                {
                                    vertexIndices.push_back(vertexIndex[0]);
                                    vertexIndices.push_back(vertexIndex[1]);
                                    vertexIndices.push_back(vertexIndex[2]);
                                }
                                else
                                {
                                    std::cout << "File read error" << std::endl;
                                    return false;
                                }
                            }
                        }
                    }
                }
            }
        }
     
        for(unsigned int i = 0; i < vertexIndices.size(); i++)
        {
            unsigned int vertexIndex = vertexIndices[i];
            glm::vec3 vertex = file_vertices[vertexIndex - 1];
            vertices.push_back(vertex);
        }
     
        for(unsigned int i = 0; i < normalIndices.size(); i++)
        {
            unsigned int normalIndex = normalIndices[i];
            glm::vec3 normal = file_normals[normalIndex - 1];
            normals.push_back(normal);
        }
     
        for(unsigned int i = 0; i < texIndices.size(); i++)
        {
            unsigned int texIndex = texIndices[i];
            glm::vec2 texcoord = file_texcoords[texIndex - 1];
            texcoords.push_back(texcoord);
        }
     
        texIndices.clear();
        normalIndices.clear();
        texcoords.clear();
        normals.clear();
     
        fclose(file);
     
     
        return true;
    }


    Here is what I have for loading the triangles to the mesh:
    Code :
    void ObjModel::btLoadTriangleMesh(btTriangleMesh* tm)
    {
    for(int i = 0; i < vertexIndices.size(); i+=3){
            glm::vec3 v1 = vertices[vertexIndices[i]];
            glm::vec3 v2 = vertices[vertexIndices[i + 1]];
            glm::vec3 v3 = vertices[vertexIndices[i + 2]];
     
            btVector3 A(v1.x, v1.y, v1.z);
            btVector3 B(v2.x, v2.y, v2.z);
            btVector3 C(v3.x, v3.y, v3.z);
            tm->addTriangle(A, B, C);
        }
     
    }

    I am getting collision with bullet but not in the correct places.
    I am not sure if I am not parsing the file correctly causing the triangles to not be correctly loaded to the mesh or if I am actually adding the triangles incorrectly.

    Here is a pastebin link for my obj file since I cannot upload it to the post.

    Any help would be greatly appreciated.

  2. #2
    Senior Member OpenGL Guru
    Join Date
    Jun 2013
    Posts
    2,926
    Quote Originally Posted by zsloan112 View Post
    Code :
        for(unsigned int i = 0; i < vertexIndices.size(); i++)
        {
            unsigned int vertexIndex = vertexIndices[i];
            glm::vec3 vertex = file_vertices[vertexIndex - 1];
            vertices.push_back(vertex);
        }

    Code :
    for(int i = 0; i < vertexIndices.size(); i+=3){
            glm::vec3 v1 = vertices[vertexIndices[i]];
            glm::vec3 v2 = vertices[vertexIndices[i + 1]];
            glm::vec3 v3 = vertices[vertexIndices[i + 2]];
    You're applying the mapping specified by vertexIndices twice. btLoadTriangleMesh() should just be using vertices[i] etc.

  3. #3
    Newbie Newbie
    Join Date
    May 2018
    Posts
    2

    Angry

    Quote Originally Posted by GClements View Post
    You're applying the mapping specified by vertexIndices twice. btLoadTriangleMesh() should just be using vertices[i] etc.
    I have tried the load triangle mesh using vertices[i] etc and and still getting the same result.

Posting Permissions

  • You may not post new threads
  • You may not post replies
  • You may not post attachments
  • You may not edit your posts
  •