BlitzForest/Grass - Dense trees & grass rendering

Note: This is two of several libraries that have been sitting on my hard drive for about a year not being used (since I have moved on to my own C++ game engine [using Ogre]). I have decided to release a few of these libraries since can be very useful to many of you, I'm sure.


Download BlitzForest & BlitzGrass Here





BlitzForest Library:
BlitzForest enables you to place thousands, and literally tens of thousands of trees in your game with little performance penalty. Using 30 thousand, or even 50 thousand trees would not be too much for BlitzForest to handle. Even old video cards will be able to render up to 50,000 trees at relatively smooth frame rates. BlitzForest's only limitation is the required use of prop-style trees.

BlitzForest uses a complex optimization method, taking full advantage of minimal-surface renders, LOD optimization, batch loading and reprocessing, and occlusion.

What makes BlitzForrest so useful is not only it's features, but the fact that all these complex operations are done automatically! All you have to worry about is using the very simple commands of BlitzForrest, such as BF_PositionTree() and BF_LoadTree().

Even though initialization of BlitzForrest and LOD settings is easy, this is probably as hard as it gets when using BlitzForrest. Simply let BlitzForrest know what detail you want your trees displayed at, and at what relative scale your world is, and you're ready to go!

Features:
• Easy-to-use functions, which automatically take care of all optimizations transparently
• Automatically optimized loading procedures, offering unmatched loading speed with thousands of trees
• Automatic single and minimal-surface render optimizations for realtime display of thousands of trees
• Automatic level-of-detail (LOD) optimizations for amazing performance
• Optimal mesh regeneration and optimization system with possible realtime tree manipulation


BlitzGrass Library:
BlitzGrass provides you with an easy way to add infinite amounts of dense, realistic, and extremely fast grass to your Blitz3D world. BlitzGrass generates grass and adds it to your terrain automatically, additionally batching grass meshes for maximum performance. Since BlitzGrass uses a built-in paging system, there's no need to pre-load grass - everything is loaded as you move around in you're world. This means that you're world could be 1000 or 1000000 units long - it makes no difference to BlitzGrass.

Very useful - Thanks !!

whew. very nice. decent. great. i think i let my grassengine die and use yours ;)

thanks very much nice one

IPete2

Thanks John!

thanks! some great code there

These numbers sound really good. But two things: you should use a ground texture that disguises the grass quads bottom lines. Basicly a texture that has about the same hue and birghtness as the grass itself. This will make it look much better.

And 2nd a question: how does it handle alpha, is it sorting it, and how does sorting interact with other alpha objects in the scene?

Well of course. Remember that the screenshots above and the demo are just for demonstration purposes - when I actually used this naturally I used a matching ground texture.


The grass quads are not individually sorted, but each batch should be. This means that there will be some incorrect alpha, but hopefully not too much.


I have used both the tree and grass system in my (canceled) BattleTanks III project, and I know for a fact that they run very well (about 90 FPS on a GeForce 5200 at moderate detail settings):

That screenshot looks brilliant!

That's looking much better. I wish I had access to this before I added grass to my project. The one that I use utilizes CopyEntity. It's pretty fast, but a contingent of 3 thousand quads already has an obvious impact on the framerate of a "worst-case-rig" radeon 9200se.

Although, it's not only the number of tris and surfaces that makes the diffrence. The higher the grass (y-scale), the more the quads are overlapping onscreen, resulting a high number of alpha levels for the renderer. At the other hand: the lower the height of the grass, the more quads you need to cover the ground. It's a dilemma.

So what is the trick of your method that allows to render 10'000 on a 5200 without high costs?

Like you mentioned, there are three major performance factors on a video card:
#1: Fill rate
#2: Batch count
#3: Polygon count

Notice that polygon count is the least important. On practically any video card past a GeForce 2, polygon count has become quite trivial in comparison to other factors (like batch count and fill rate).

Batch count refers to the number of individual draw calls Blitz3D (or whatever engine you use) has to make. By combining multiple objects into a single object, you can reduce the draw calls, even though the polygon count stays the same. This can lead to EXTREMELY high boosts of frame rate. For example, drawing 20,000 mesh trees individually on a GeForce 7800 GT barely runs at 1 FPS, while grouping them into ~20-30 batches runs at 150 FPS.

And often the most important (depending on the nature of your geometry) is fill rate. Like you mentioned, reducing the y-scale reduces the amount of pixels used by each grass quad, and therefore boosting performance. If you have a modern card, grass shouldn't be too much of a problem, but cards like a 5200 have terrible fill rates and really benefit from lower grass heights.

The only real way to avoid the fill rate bottleneck on older cards is to either scale down your grass, or possibly try alpha-rejection on your textures (called "masking" in Blitz3D). Alpha-rejection rejects transparent pixels from being unnecessarily processed from the pixel pipeline, which can help slightly (although I don't think Blitz3D allows both masking and alph at the same time).


Batching and low y-scale. There's not much else you can do beyond that - at this point you've pretty much reached the limits of your hardware.

Open land as in your screenie is very hard to achieve. I am rather trying to design levels with a low camera range. For example, a canyon enviroment that allows rich vegetation at all times.

You mean like this? (p.s. the trees are just placeholders - I know they look bad)

(View movie here)



I'm designing my current game engine to handle it all - dense swamplands, wide open grassy planes, mountainous forests, etc., :)

(I guess this is a little bit off topic, but I'm sure some of you are a little interested in why I'm giving my old code away ;) )

what did you make the trees in? I wish I could make better trees

I used Blender. The trees above are really very simple, just a square-ish trunk with a dome top textured with leaves.

Xira engine is your new engine with c++?

Thanks again John, this looks very cool! !!!!

Yup, very nice, thank you John for this really *good* tree library !

Sergio.

Yes, that's what I'm planning on calling it. It's actually more of a framework, so unfortunately I don't think I could port it to BlitzMax without converting the entire engine (though I probably could add my tree/grass system to something like Flow). When it's done it'll probably be more like Torque to the "casual" developer, but with a very powerful world/script editor and many advanced features like hardware grass animation, highly optimized 3D trees (for 50,000+ tree forests), splatting terrains, possibly dynamic tree destruction, portal occlusion, horizon occlusion (hopefully), full shader support + fallback system (since I'm using Ogre for rendering) etc. The demo used to make the screenshots/video above (10,000 trees, animated grass, 50 physically simulated boxes) runs at ~300 FPS on a Gf7800, and ~30 FPS on a Gf5200.

John, how to place this grass chunks on to mesh terrain?? There is no specific BG command for positioning...

You don't specifically position the grass. Instead you first add a grass layer (which appears everywhere), then apply a grassmap. The grassmap should be a greyscale image just like your heightmap, but instead of setting terrain height, the grassmap sets grass density.

P.S. I'm not sure if the grass map functions are working 100% - I think the axes might be inverted or swapped. Also, the grass map isn't smoothed, so the grass densities may appear in blocks. This is the one section of BlitzGrass that I never finished (and unfortunately, I probably don't have enough time to finish it now due to other projects).

yes..that should be fine with terraing made from bitmap, but what about mesh terrains?? How to use gras system with with mesh terrains?

In this case you'll have to create you're own MeshTerrainY() function that operates similarly to Blitz3D's TerrainY() and change the TerrainY() calls in BlitzGrass to MeshTerrainY() (or whatever).

John, dont know if I'm doing something wrong or not but I can't seem to get the grass system to work with a grassmap, it just ignores it and places the grass all over the grass layer.
In fact, you've commented out the grassmap function in your demo.
Any idea's what i might be doing wrong or what might be wrong with the grassmap function.

Nexus6: I'm not sure why that's happening, but like I said the grassmap feature wasn't finished, and I probably don't have time to finish this when I already have a much nicer grass system working in C++.

Hopefully the grass library will at least provide a good starting point for anyone who needs it (although the tree system should be 100% working).

P.S. If you're "fluent" in C++, my latest project might be helpful here (especially GrassLoader.cpp), since it's density/color map features are complete.

Nice stuff John! That pic above is pretty, but tell me, can we have the StickyBoulderOnSlope code too? :P

Great system thanks! Is it possible to implement it into a world editor to put grass in certain places? I don't ask you to do it but is it just possible? :)

this is really great, thank you very much. Can anyone tell my how I can load treemeshes instead of images?

BlitzForest isn't capable of doing that, unfortunately.


With grassmaps it is, but like I said above I don't think the grassmap support included is fully working.

On these lines:

		xp# = Rnd(x - BG_BlockSize, x + BG_BlockSize)
		zp# = Rnd(z - BG_BlockSize, z + BG_BlockSize)
		
		Density = BG_sysArrayGet(em\GrassMap, scl*xp, scl*zp)
		If Rand(0, 255) < Density Then

If you set Density to a value between 0 and 255, depending on how dense you want the grass at (xp, zp), you should be able to have full control over the density.


You mean the soft-edged minimap? :D

/me rubs eyes.. so it is! :P