# OpenGL Looking for heightmap (not landscape) optimization

This topic is 4755 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

## Recommended Posts

Hi everybody, I feel a bit lost with my latest OpenGL project. I'm looking for a solution to optimize my rendering that displays a surface that is rendered from a 1000 x 1000 height map (yes, that's 1 million vertices, all visible at once, currently). The surface which is rendered from the height map is usually completely visible to the user, therefor I don't have any culling algorithms involved. The surface is just plain flat shaded in several colors, so no texturing is done - however it's getting slow lately. I was able to save a lot of vertex transfers by using triangle or quad strips, which made it render about 50% faster. I also tried display lists, but they always make it crash if used with too much vertices. I didn't try vertex arrays yet; probably that'd give it another boost on performance. The best idea would be to reduce the number of shown polys, but I'm not sure which is the best approach. I could either try to reduce the tri/quad count by trying to merge tris/quads that are next to each other and have the same face normal (like a lossless mesh simplification) - or I could try to dynamically reduce the tri/quad count for spots that are far away (LOD). I read a lot about mesh simplification, tesselation, and LOD algos during the last days, but now I feel even more lost. Most stuff I read was about terrain rendering (where you usually only see a small area of the heightmap) and mesh simplification that was intended to be done before rendering (not in realtime). I'd appreciate any hints and ideas on how I could speed up my rendering

##### Share on other sites
Hi,

The easiest way for you to get some more speed would be to use vertex buffer objects (if you have it implemented with vertex arrays then you are pretty much there).
However, I can't think of many reasons for rendering such a big mesh unless you are making some sort of level editing/creation application. In which case, surely you don't need to update it that often.

Heightmap lod algorithms have their advantages and disadvantages depending on the situation, so if you do want to implement lod you should have a look at roam, clod and geomipmapping (among others [smile]) and see which one would best suit your needs.

Regards,
ViLiO

##### Share on other sites
Yes I definitely should give vertex buffer objects a try. I'm still in the progress of learning how they work :)

But I'm confused about what is written about optimizations. At several places I read that ROAM is not very useful anymore today. With nowadays cards, it's told to be more effective to let the GPU handle the additional vertices than keeping the CPU busy with ROAM calculations. I wonder if this would still apply to my case (1 million vertices sounds very high to render them all to me, and maybe I need to go even higher)

I wonder if I should concentrate on reducing the tri/quad count somehow (ROAM) or on increasing processing speed (e.g. by using vertex buffer objects).

##### Share on other sites
Hi again,

I must admit I am puzzled by your need to render so much data all at the same time [smile]. You say the whole heightmap is visible most of the time ...but in which way do you view it? If you are looking across the mesh from a low camera angle then you were benefit greatly from some sort of lod (probably geomipmapping) and of course you could make use of occlusion. Lod would allow you to greatly reduce the vertex count of the parts of the heightmap that are far from the camera. Occlusion has obvious benefits [grin]
It would be a good idea to split your heightmap up into 65x65 chunks anyway, as having a vertex buffer object that is too large causes slowdown (65x65 vertices is good for most hardware but you can of course experiment). The whole heightmap can also be tri-stripped quite easily.

Best of luck,
ViLiO

##### Share on other sites
It's hard to explain what the project does that I'm working on. The user can see an object from above and modify its surface at runtime. It looks a little like you would write letters with your finger into the sand. The user usually looks at the working object from above, but he should be able to zoom in a lot without loosing too much details. So I created a huge height map which has a high enough resolution and used it to present my objects surface. Unfortunately my first attempt to draw a quad onto each 4 adjacent heights to form a surface worked first, but (of course) became extremely slow now that the heightmap became so huge.

I don't necessarily need to render all the data of the heightmap. If the user has zoomed out, there's no need to render every vertex, because they can't be distinguished anyway :). It's just that I need to store the data in such a high resolution so that the user would be able to zoom in and see details.

LOD, ROAM, Geomipmapping, I read a lot about all the methods and I think I basically understand them all, but where I'm getting more and more confused is that all articles and papers I read are related to terrain rendering (which is somewhat different to what I do, e.g. in my case the heights aren't fixed and geomipmaps can't be precalculated, and the user usually sees the whole heightmap area, not only a small part of it (which would make frustum culling useless, at least unless the user doesn't zoom in a lot)

I was also thinking about partitioning the heightmap into several smaller pieces by using a quadtree and somehow using some of the tree nodes to generate geomipmaps in realtime, but I'm not sure if that wouldn't drastically increase the memory usage (e.g.for linking so many tree nodes)

In some articles they mentioned that nowadays it's often faster/better to let the GPU handle some additional polygons than wasting CPU cycles for removing invisible polygons. E.g. in my case a user would watch the whole object 90% of his time, which makes frustum culling useless. Even if he zooms in, I'd say that at a maximum he still sees 50% of the object. That doesn't sound like frustum culling would make sense in my case - but I'm just missing experience when it comes to this, and so I'm getting confused more and more :-)

##### Share on other sites
Well, the last thing I can suggest is parallax mapping.
I suspect I am about to go way over my head here considering I have never implemented parallax [grin].

From my limited knowledge, parallax is similar to bump mapping, only it gives the appearance of full displacement mapping (aka heightmap). This would mean you would only need to change texture data and not move individual vertices, so you could have a single quad with a 1024x1024 parallax map. The downside is that it is an image based technique and doesn't actually modify vertices, so if viewed from acute angles, you can see that the quad would actuall be flat.

Hopefully though i've given you some food for thought [smile]

All the best,
ViLiO

##### Share on other sites
Well I'm sure vertex buffer objects would help. They might not work for the same reason as display lists though. Try chopping your mesh into 4 or more chunks, and see if it can handle it then.

Not sure how much this will help, but it's something to try. When the user can see the whole thing, you obviously don't need that much detail (you probably have a near 1 to 1 ratio of poly's and pixels). Now your not the usual fps player that needs detail close up and not further away, your a high up observer. So, I suggest just dropping 3 quarters of the polys. Rather than making a mesh that uses every vertex, skip every second one. So,
.---.---.|   |   |.---.---.|   |   |.---.---.becomes.---.---.|       |.   .   .|       |.---.---.

You'll need the detail when you zoom in though, but hopefully then you can cull some of your mesh. Rather than doing it yourself, I'd recommend the vertex culling extension.

##### Share on other sites
I'm doing something similar and I'm doing this:

1) I create a mesh which is really simple and optimized then I save it into RAM
2) Move this mesh (usually 1024x1024) to the video card using VBO.
3) Load a heightmap and the corresponding normal map.
4) Displace the mesh in the vertex shader using texture fetch.
5) Do per-pixel lights with the pre-calculated normal maps
6) Done.

I normally get around 30-40 fps in a 6800gt. I'm sure you can get a better fps if you:
a) Divide the mesh into smaller chunks for optimization.
b) Cull the unnecessary polygons when zomming.

Hope that help.
:)

##### Share on other sites
From your description, it seems like the heightmap is mostly fixed. The exception is that every frame a relatively small area is changed. Assuming that is true, then a LOD terrain algorithm (particularly geomipmapping) is appropriate.

You wrote, "in my case the heights aren't fixed and geomipmaps can't be precalculated". That is not true.

The reason I suggest geomipmapping is how it implements LOD. In geomipmapping, LOD is achieved through a predetermined method of vertex selection and is independent of the data (except for determining the LOD thresholds). So when the heightmap changes, all you have to do is determine the new LOD thresholds. You could even skip that if you don't mind some popping.

Normally for rendering a terrain, I recommend "Chunked LOD", but it requires some preprocessing so it is probably not appropriate in this case.

##### Share on other sites
Thanks everybody. I'm still not sure how I should go on, but this gave me a good overview on which topics I should do deeper searches. From what I know now, I should mostly look into geomipmapping to decrease details of not-so-important (far away) places and maybe ROAM to reduce the overall number of tris.

1. 1
2. 2
Rutin
18
3. 3
4. 4
5. 5

• 11
• 14
• 9
• 9
• 9
• ### Forum Statistics

• Total Topics
632922
• Total Posts
3009226
• ### Who's Online (See full list)

There are no registered users currently online

×