Draw 2D Mesh Grid using GLSL in 3D space


I'm hoping to draw a 2D Grid within a finite space on the X axis using OpengGL 4.0.

I wish to use GLSL using vert/frag shaders etc for rending the light (making them appear).

It can be done with the simplest code using older OpenGL 2.0 methods but then of course it doesn't use lighting/shaders to colour them:

    void Draw_Grid()
     for(float i = -500; i <= 500; i += 5)
            glColor3ub(150, 190, 150);
            glVertex3f(-500, 0, i);
            glVertex3f(500, 0, i);
            glVertex3f(i, 0,-500);
            glVertex3f(i, 0, 500);

But I can'd find any tutorials other than this one which I don't understand well enough to convert from a graph to a simple 2D Grid in 3D space.

Best Solution

Yes, you can use just shaders to generate your geometry...

  1. Don't bind any VBOs.
  2. Call glDrawArrays()
  3. Use gl_VertexID in the vertex shader or gl_PrimitiveID in the geometry shader to procedurally generate your stuff.

It can be faster exactly because there are no vertex attributes or input data. Not to mention the space saved and initialization time is next to nothing.

Here's an example of a vertex shader that draws a grid with GL_TRIANGLES:

#version 150

uniform mat4 modelviewMat;
uniform mat3 normalMat;
uniform mat4 projectionMat;

uniform ivec2 dim;

out vec3 esNorm;

const vec2 triOffset[] = vec2[](

void main()
    int triVert = gl_VertexID % 6;
    int gridIndex = gl_VertexID / 6;
    vec2 coord = vec2(gridIndex / dim.x, gridIndex % dim.x);
    coord = (coord + triOffset[triVert]) / vec2(dim);
    vec4 esVert = modelviewMat * vec4(coord * 2.0 - 1.0, 0.0, 1.0);
    gl_Position = projectionMat * esVert;
    esNorm = normalMat * vec3(0.0, 0.0, 1.0);

I did have some trouble drawing without VBOs bound on my ancient ATI card. This approach works fine on my Nvidia cards with new drivers. Discussed further here: Opengl, DrawArrays without binding VBO, where glDrawArraysInstanced/gl_InstanceID is suggested as an alternative.

A further note. I've noticed modulo % arithmetic can be a little slow in some cases. Using simpler bitwise operations or other tricks may speed things up.

Related Question