CODEWITHSUNDEEP
openglperformanceconceptual
James Eichele
James Eichele

Reputation: 119144

What is the most efficient way to manage a large set of lines in OpenGL?

I am working on a simple CAD program which uses OpenGL to handle on-screen rendering. Every shape drawn on the screen is constructed entirely out of simple line segments, so even a simple drawing ends up processing thousands of individual lines.

What is the best way to communicate changes in this collection of lines between my application and OpenGL? Is there a way to update only a certain subset of the lines in the OpenGL buffers?

I'm looking for a conceptual answer here. No need to get into the actual source code, just some recommendations on data structure and communication.

Upvotes: 6

Views: 722

Answers (4)

Kalle
Kalle

Reputation: 141

My suggestion is to try using a scene graph, some kind of hierarchical data structure for the lines/curves. If you have huge models, performance will be affected if you have plain list of lines. With a graph/tree structure you can check easily which items are visible and which are not by using bounding volumes. Also with a scenegraph you can apply transformation easily and reuse geometries.

Upvotes: 2

sinoth
sinoth

Reputation: 7672

Not sure if you're already doing this, but it's worth mentioning you should try to use GL_LINE_STRIP instead of individual GL_LINES if possible to reduce the amount of vertex data being sent to the card.

Upvotes: 2

grepsedawk
grepsedawk

Reputation: 6059

You can use a simple approach such as using a display list (glNewList/glEndList)

The other option, which is slightly more complicated, is to use Vertex Buffer Objects (VBOs - GL_ARB_vertex_buffer_object). They have the advantage that they can be changed dynamically whereas a display list can not.

These basically batch all your data/transformations up and them execute on the GPU (assuming you are using hardware acceleration) resulting in higher performance.

Upvotes: 8

Branan
Branan

Reputation: 1819

Vertex Buffer Objects are probably what you want. Once you load the original data set in, you can make modifications to existing chunks with glBufferSubData().

If you add extra line segments and overflow the size of your buffer, you'll of course have to make a new buffer, but this is no different than having to allocate a new, larger memory chunk in C when something grows.

EDIT: A couple of notes on display lists, and why not to use them:

  1. In OpenGL 3.0, display lists are deprecated, so using them isn't forward-compatible past 3.0 (2.1 implementations will be around for a while, of course, so depending on your target audience this might not be a problem)
  2. Whenever you change anything, you have to rebuild the entire display list, which defeats the entire purpose of display lists if things are changed often.

Upvotes: 7

Related Questions