0

I'm using shaders and the programmable pipeline, I need to connect two meshes with a line (maybe colored) but I just have the model matrices of these two objects. The line should start at the center of these objects so I assume the object-coords of the two points should be:

start point: 0,0,0
end point: 0,0,0

to connect the two objects I assume I'll have to multiply these points in the shader by their respective object's model matrix. And then multiply everything by the view matrix (this is common to the two objects). And eventually by the projection matrix.

I've always used shaders with vertex arrays, how would I pass two different vertices to a shader? Should I use uniforms for them too? And what function should I use to draw the line since both glDrawElements and glDrawArrays require a data array?

Johnny Pauling
  • 12,701
  • 18
  • 65
  • 108
  • 1
    If you want many lines (100s, 1000s), then sending the points as uniforms is inefficient. Also, how would you draw the line? There are ways (geometry shader outputting lines_strips or fragement shader testing each pixel), but this is unecessarily convoluted. – torbjoernwh Jul 21 '12 at 19:06
  • Ok, if I need to use an array, can you kindly provide me an example on how to do that please? – Johnny Pauling Jul 21 '12 at 19:10
  • 1
    Here's the same question, but for fixed function GL: http://stackoverflow.com/questions/11593053/opengl-draw-line-between-two-elements – torbjoernwh Jul 21 '12 at 19:55

1 Answers1

2

The most straightforward method would be to create a VBO containing the worldspace points of all the lines you wish to draw with GL_LINES.

The easiest is to use glDrawArrays. If you have extreme amounts of object pairs that need lines between (10.000s+) then it might make sense to store all the points in a VBO, and then use a IBO (index buffer) to say what points in the VBO are connected by a line.

The line vertices would still have to be transformed by the view matrix.

Here's an example: GLuint vao, vbo;

// generate and bind the vao
glGenVertexArrays(1, &vao);
glBindVertexArray(vao);

// generate and bind the buffer object
glGenBuffers(1, &vbo);
glBindBuffer(GL_ARRAY_BUFFER, vbo);

struct Point{ 
    float x,y,z; 
    Point(float x,float y,float z) 
                    : x(x), y(y), z(z) 
    {} 
};

// create two points needed for a line. For more lines, just add another point-pair
std::vector<Point> vertexData;
vertexData.push_back( Point(-0.5, 0.f, 0.f) );
vertexData.push_back( Point(+0.5, 0.f, 0.f) );

// fill with data
size_t numVerts = vertexData.size();
glBufferData(GL_ARRAY_BUFFER, sizeof(Point)*numVerts, &vertexData[0], GL_STATIC_DRAW);

// set up generic attrib pointers
glEnableVertexAttribArray(0);
glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, numVerts*sizeof(Point), (char*)0 + 0*sizeof(GLfloat));

// "unbind" vao
glBindVertexArray(0);

// In your render-loop:
glBindVertexArray(vao);
glDrawArrays(GL_LINES, 0, numVerts);

If you need to add more point-pairs during runtime, update the std::vector, bind the VBO and call glBufferData.

torbjoernwh
  • 445
  • 3
  • 9