Create a grid in OpenGL

Question

I need to generate a NxN resolution grid in the xy-plane with OpenGL. The final grid needs to be made by triangles (GL_TRIANGLES), so it should seem like the following example:

 ^
 *   |  ----------
 *   |  |\ |\ |\ |
 *   |  | \| \| \|
 *   |  ----------
 *   |  |\ |\ |\ |
 * y |  | \| \| \|
 *   |  ----------
 *   |  |\ |\ |\ |
 *   |  | \| \| \|
 *   |  ----------
 *   |
 *   |-------------->
 *          x

Note that I need to store the grid in vertex-index form (given the structures by parameters).

My code at this point:

void generate_grid(
std::uint32_t N,
std::vector<glm::vec3>* vertices,
std::vector<glm::uvec3>* indices)
{
    for (int i = 0; i < N; i++) {
        glBegin(GL_TRIANGLES);
    for (int j = 0; j < N; j++) {
        int vertexNum = indices;  // Index for vertex j of face i.
        double[] vertexCoords = vertices[vertexNum];  // The vertex itself.
        glVertex3f(vertexCoords, 0);
    }
    glEnd();
} 

Any advice? Regards.

Answer 1

Since the language is C++ and you are using a std::vector you should change the function signature and pass the parameters by reference instead of by pointer.

void generate_grid(int N, std::vector<glm::vec3> &vertices, std::vector<glm::uvec3> &indices);

First you have to fill the vertex array. Note, for a N*N field you need (N+1)*(N+1) vertices. Second you have to generate the triangle indices, for each field you have to generate 2 triangles:

 float f(float x, float y)
{
    // use any curve function you want
    return sin(x*2.0f*3.141526f) * sin(y*2.0f*3.141526f) * 0.1f;
}

void generate_grid(int N, std::vector<glm::vec3> &vertices, std::vector<glm::uvec3> &indices)
{
    for (int j=0; j<=N; ++j) 
    {
        for (int i=0; i<=N; ++i)
        {
            float x = (float)i/(float)N;
            float y = (float)j/(float)N;
            float z = f(x, y);
            vertices.push_back(glm::vec3(x, y, z));
        }
    }

    for (int j=0; j<N; ++j) 
    {
        for (int i=0; i<N; ++i)
        {
            int row1 = j * (N+1);
            int row2 = (j+1) * (N+1);  

            // triangle 1
            indices.push_back(glm::uvec3(row1+i, row1+i+1, row2+i+1)); 

            // triangle 2
            indices.push_back(glm::uvec3(row1+i, row2+i+1, row2+i)); 
        }
    }
}

The old school and deprecated way to draw this, would be like this:

void draw_grid(const std::vector<glm::vec3> &vertices, const std::vector<glm::uvec3> &indices)
{
    glBegin(GL_TRIANGLES);
    for ( auto i : indices )
    {
        glVertex3fv(glm::value_ptr(vertices[i.x]));
        glVertex3fv(glm::value_ptr(vertices[i.y]));
        glVertex3fv(glm::value_ptr(vertices[i.z]));
    }
    glEnd();
}

The common way to draw geometry is to create a Vertex Array Object:

GLuint generate_vao(const std::vector<glm::vec3> &vertices, const std::vector<glm::uvec3> &indices)
{
    GLuint  vao;
    glGenVertexArrays( 1, &vao );
    glBindVertexArray( vao );

    GLuint vbo;
    glGenBuffers( 1, &vbo );
    glBindBuffer( GL_ARRAY_BUFFER, vbo );
    glBufferData( GL_ARRAY_BUFFER, vertices.size()*sizeof(glm::vec3), glm::value_ptr(vertices[0]), GL_STATIC_DRAW );
    glEnableVertexAttribArray( 0 );
    glVertexAttribPointer( 0, 3, GL_FLOAT, GL_FALSE, 0, nullptr );

    GLuint ibo;
    glGenBuffers( 1, &ibo );
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, ibo );
    glBufferData( GL_ELEMENT_ARRAY_BUFFER, indices.size()*sizeof(glm::uvec3), glm::value_ptr(indices[0]), GL_STATIC_DRAW );

    glBindVertexArray( 0 );
    glBindBuffer( GL_ELEMENT_ARRAY_BUFFER, 0 );
    glBindBuffer( GL_ARRAY_BUFFER, 0 );

    return vao;
}


void draw_vao( GLuint vao, GLsizei n )
{  
    glBindVertexArray( vao );
    glDrawElements( GL_TRIANGLES, (GLsizei)n, GL_UNSIGNED_INT, NULL );
    glBindVertexArray( 0 );
}

std::vector<glm::vec3> vertices;
std::vector<glm::uvec3> indices;

GLuint vao = generate_vao( vertices, indices );
.....
draw_vao( vao, (GLsizei)indices.size()*3 );