3
\$\begingroup\$

I am trying to render 2 types of primitives- - points ( a Point Cloud ) - triangles ( a Mesh )

I am rendering points simply without any index arrays and they are getting rendered fine. To render the meshes I am using indexed drawing with the face list array having the indices of the vertices to be rendered as Triangles. Vertices and their corresponding vertex colors are stored in their corresponding buffers. But the indexed drawing command do not draw anything.

The code is as follows-

Main Display Function:

    void display()
    {
        simple->enable();
        simple->bindUniform("MV",modelview);
        simple->bindUniform("P", projection);

        // rendering Point Cloud
        glBindVertexArray(vao);

        // Vertex buffer Point Cloud
        glBindBuffer(GL_ARRAY_BUFFER,vertexbuffer);
        glEnableVertexAttribArray(0);
        glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);

        // Color Buffer point Cloud
        glBindBuffer(GL_ARRAY_BUFFER,colorbuffer);
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,0,0);

        // Render Colored Point Cloud
        //glDrawArrays(GL_POINTS,0,model->vertexCount);

        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        // ---------------- END---------------------//

        //// Floor Rendering
        glBindBuffer(GL_ARRAY_BUFFER,fl);
        glEnableVertexAttribArray(0);
        glEnableVertexAttribArray(1);
        glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);
        glVertexAttribPointer(1,4,GL_FLOAT,GL_FALSE,0,(void *)48);

        glDrawArrays(GL_QUADS,0,4);
        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        // -----------------END---------------------//

        //Rendering the Meshes
        //////////// PART OF CODE THAT IS NOT DRAWING ANYTHING ////////////////////
        glBindVertexArray(vid);
        for(int i=0;i<NUM_MESHES;i++)
        {
            glBindBuffer(GL_ARRAY_BUFFER,mVertex[i]);
            glEnableVertexAttribArray(0);
            glEnableVertexAttribArray(1);
            glVertexAttribPointer(0,3,GL_FLOAT,GL_FALSE,0,0);
            glVertexAttribPointer(1,3,GL_FLOAT,GL_FALSE,0,(void *)(meshes[i]->vertexCount*sizeof(glm::vec3)));

            //glDrawArrays(GL_TRIANGLES,0,meshes[i]->vertexCount);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mFace[i]);
            //cout<<gluErrorString(glGetError());
            glDrawElements(GL_TRIANGLES,meshes[i]->faceCount*3,GL_FLOAT,(void *)0);

            glDisableVertexAttribArray(0);
            glDisableVertexAttribArray(1);
        }

        glUseProgram(0);    
        glutSwapBuffers();
        glutPostRedisplay();
    }

Point Cloud Buffer Allocation Initialization:

        void initGLPointCloud()
        {
            glGenBuffers(1,&vertexbuffer);
            glGenBuffers(1,&colorbuffer);
            glGenBuffers(1,&fl);
            //Populates the position buffer
            glBindBuffer(GL_ARRAY_BUFFER,vertexbuffer);
            glBufferData(GL_ARRAY_BUFFER, model->vertexCount * sizeof (glm::vec3),
                    &model->positions[0], GL_STATIC_DRAW);

            //Populates the color buffer
            glBindBuffer(GL_ARRAY_BUFFER, colorbuffer);
            glBufferData(GL_ARRAY_BUFFER, model->vertexCount * sizeof (glm::vec3),
                    &model->colors[0], GL_STATIC_DRAW); 

            model->FreeMemory();    // To free the not needed memory, as the data has been already 
                                    // copied on graphic card, and wont be used again.
            glBindBuffer(GL_ARRAY_BUFFER,0);
        }

Meshes Buffer Initialization:

        void initGLMeshes(int i)
        {
            glBindBuffer(GL_ARRAY_BUFFER,mVertex[i]);
            glBufferData(GL_ARRAY_BUFFER,meshes[i]->vertexCount*sizeof(glm::vec3)*2,NULL,GL_STATIC_DRAW);
            glBufferSubData(GL_ARRAY_BUFFER,0,meshes[i]->vertexCount*sizeof(glm::vec3),&meshes[i]->positions[0]);
            glBufferSubData(GL_ARRAY_BUFFER,meshes[i]->vertexCount*sizeof(glm::vec3),meshes[i]->vertexCount*sizeof(glm::vec3),&meshes[i]->colors[0]);
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,mFace[i]);
            glBufferData(GL_ELEMENT_ARRAY_BUFFER,meshes[i]->faceCount*sizeof(glm::vec3),
                &meshes[i]->faces[0],GL_STATIC_DRAW);

            meshes[i]->FreeMemory();
            //glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
        }

Initialize the Rendering, load and create shader and calls the mesh and PCD initializers.

void initRender() 
{

            simple= new GLSLShader("shaders/simple.vert","shaders/simple.frag");

            //Point Cloud
            //Sets up VAO
            glGenVertexArrays(1, &vao);
            glBindVertexArray(vao);

            initGLPointCloud();

            //floorData 
            glBindBuffer(GL_ARRAY_BUFFER, fl);
            glBufferData(GL_ARRAY_BUFFER, sizeof(floorData),
                    &floorData[0], GL_STATIC_DRAW); 

            glBindBuffer(GL_ARRAY_BUFFER,0);

            glBindVertexArray(0);
            //Meshes
            for(int i=0;i<NUM_MESHES;i++)
            {
                if(i==0) // SET up the new vertex array state for indexed Drawing
                {
                    glGenVertexArrays(1, &vid);
                    glBindVertexArray(vid);
                    glGenBuffers(NUM_MESHES,mVertex);
                    glGenBuffers(NUM_MESHES,mColor);
                    glGenBuffers(NUM_MESHES,mFace);
                }
                initGLMeshes(i); 
            }
            glEnable(GL_DEPTH_TEST);    
        }

Any help would be much appreciated, I have been breaking my head on this problem since 3 days, and still it is unsolved.

\$\endgroup\$
1
\$\begingroup\$

Firstly, in your call to glDrawElements you pass GL_FLOAT. This should be one of GL_UNSIGNED_BYTE, GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT (depending on the type of faces). I imagine you would get an GL_INVALID_ENUM returned from glGetError.

Secondly, in the line:

glBufferData(GL_ELEMENT_ARRAY_BUFFER,meshes[i]->faceCount*sizeof(glm::vec3),
             &meshes[i]->faces[0],GL_STATIC_DRAW);

The second parameter should be: meshes[i]->faceCount*3*sizeof(IndexType) (where IndexType is whatever you have declared faces as.

Generally it is a good idea to check glGetError after more or less every GL call. You can do this using a macro that logs any errors in debug mode, but does nothing in release mode.

\$\endgroup\$

Your Answer

By clicking “Post Your Answer”, you agree to our terms of service, privacy policy and cookie policy

Not the answer you're looking for? Browse other questions tagged or ask your own question.