Author: by Daniel Sánchez-Crespo Dalmau

Outdoor environments and tree rendering have become hot topics ever since fill-rate was conquered some time in the last five years. We're no longer limited to tunnels and dungeons, and that gives us so much more creative liberty-but at the cost of higher-complexity algorithms. Terrain rendering has been mastered with algorithms like ROAM and geo-mipmapping. Tree rendering, on the other hand, is still a difficult problem. Some companies have developed their own proprietary tree rendering systems, while others build licensable components, which give us a (more or less) turn-key solution. In this article I will review two of the most popular licensable tree technologies: the one developed by the French company Bionatics (consisting of the NatFX and RealNAT products), and SpeedTree RT, by Interactive Data Visualization (IDV). These packages are clearly not competing for the same market niche, as their feature sets are very different: Bionatics is a modeling solution, while SpeedTree is a mixed modeling and rendering package. Thus, this will not be a head-to-head comparison. Rather, I'll analyze each one on its own merits, based on what each package is trying to achieve. Think of this as two sequential reviews rather than a comparison.

Bionatics NatFX and RealNAT

Bionatics is a French spin-off of CIRAD, a research center focused on computational models for plant growth and visual representation. Their core technology (called AMAP) creates virtual plant "DNA", which you can evolve to generate a specific tree at different stage in its growth -- and display it in different seasons. The company has rolled out a complete product line based on this technology, NatFX and RealNAT being the versions suitable for game development. NatFX is a high-polygon tree generator and optimizer which is available as Maya and 3ds max plug-ins, while RealNAT is a stand-alone application that uses clever algorithms to create low-polygon trees. Let's review each one in detail.

NatFX basically covers two fronts. On one hand, it allows you to interact with virtual plant DNA, creating stunning high-polygon trees in the process. Trees can be in the tens of thousands triangle count range, and look extremely realistic. In fact, Bionatics' trees are among the most realistic digital trees my team has ever seen. The second front covered by NatFX is applying image-based algorithms to the tree, so it can be greatly reduced for real-time use. NatFX uses non-orthogonal textured planes to substitute large clusters of geometry by a single textured quad, achieving big savings in the process. You can then save this tree along with its textures for real-time use. As NatFX is a modeling-only solution, your software will have to load the model and implement some LOD between different tree versions to ensure trees located far away do not eat the entire fill rate. New in version 1.8 is a much faster and better-looking triangle reduction method, which was much slower in the previous release. Creating trees in the hundreds-of-triangles range is now possible with little effort, thanks to some clever billboarding. These trees can act as placeholders, so you can use the actual high-resolution model for closer trees, and mid-resolution representations for trees located further away.

RealNAT takes the process one step further, enabling the creation of billboards or quasi-billboards for your trees. RealNAT is a stand-alone application, which means you don't have to fire up 3ds max or Maya when all you want to do is create a tree. RealNAT's workflow is pretty similar to NatFX's: you interact with the DNA to create trees, change a tree's age, its season, and so on. Results are as good as with NatFX, as the underlying technology is the same. Then, once the tree has been modeled, you can apply a variety of strategies to aggressively reduce its triangle count beyond what NatFX offers. You can simplify the whole tree to a single billboard, to a crossed-quad strategy, to a crossed-plus-horizontal quad strategy, and so on. RealNAT can then tweak the billboards so the resulting data set looks good from all angles. When complete, trees can be exported to OpenFlight (flt), VRML 1 and VRML 2 (wrl), 3D Studio (3ds), and Wavefront (obj) formats.

As you can see, the difference between the two systems is that NatFX covers the high- and mid-polygon count scenarios, while RealNAT works great when all you need are one to four triangles per tree. Ideally, you would use both in conjunction, to cover the spectrum and generate a range of trees from simple billboards to full-fledged geometry-based trees.

Both systems work on a "nursery" basis: there is a virtual nursery of trees (consisting of more than 300 tree types), and you can buy extra trees as needed (in both cases the base package comes with 10 trees that you may select). You cannot create new trees yourself, as the virtual DNA technology is too complex for user manipulation. If the library doesn't include a specific tree you require, Bionatics can be hired to create a custom tree with its own virtual DNA. The company also offers its services to assist in integrating the trees into game engines.

Evaluating NatFX and RealNAT was a complex task, and filled me with mixed emotions. To begin with, the core technology deserves nothing but pure praise: trees look perfect, and the system can generate shrubs and flowers of the same high quality. Both NatFX and RealNAT are well designed, and feature a very natural workflow. Simplifying a very complex tree in NatFX can sometimes take a while (it took us around 20 seconds to turn a 400,000-triangle pine tree into a 380 triangle version on an Athlon 1.3Ghz machine), but that's understandable because of the triangle counts involved.

This means that NatFX is the way to go if you need realistic trees for a cinematic sequence, and need AAA results. The ability to grow the same tree and see how it changes with seasons really puts NatFX ahead of the competition in terms of quality. On a negative side, being a modeling-only solution greatly limits the suitability of Bionatics' products for real-time environments. Tree handling is both a modeling and rendering problem: you need a good tree model, but you need to incorporate the rendering portion as well: trees vary their detail dramatically depending on distance, and your code needs to understand that. Bionatics' products put most of the coding burden on the developer. Issues such as shadow rendering, animation and lighting are complex problems, and NatFX or RealNAT won't offer much help in those areas, so you'll need to devote developer man-hours to those tasks.

On the other hand, both Bionatics tools are reasonably inexpensive, as there is no per-project fee involved (unless you plan to publish your plant models, in which case there's a publishing fee). RealFX retails for $1,350 with ten plants of your choice, and a version with fifty trees retails at just $3,350. NatFX starts at $990 (ten trees) and climbs up to $2,990 in the fifty-tree version. Additional trees are sold on per-tree payment model, which might seem awkward, but on the other hand, prices are quite reasonable.

IDV's SpeedTree RT

SpeedTree RT is a hybrid 3D modeler and runtime engine that helps developers integrate great-looking trees in real-time applications quickly. The focus is not so much on best-possible quality as with NatFX, but in keeping a balance between quality and real-time suitability. As such, the approach is different than the one Bionatics takes. IDV, the company behind SpeedTree, comes from a visualization background, and it shows everywhere in the product design.

Tree handling is divided into two different subtasks. First, you generate realistic tree models using an editing tool, much like Bionatics' products. Second, you apply proprietary algorithms to render the trees efficiently. This approach is interesting, and attacks the core of the problem: As tree geometry is inherently complex, and sometimes the tree will be seen far away, it's very hard to handle the problem with a modeling-only solution. Understanding the modeling and rendering parts fully is essential to get good trees up and running quickly.

The first component in the SpeedTree suite is the tree modeler, which can be used both as a stand-alone application, or integrated within 3ds max. SpeedTree creates hierarchical models of each tree, so leaves are linked to their branches, branches to the trunk, and so on. This means trees can be animated quite realistically, with leaves swinging and branches arching depending on the wind strength. Modeling is a hybrid of geometry (for the trunk) and image-based, screen-aligned billboards for leaf clusters. Because trees are modeled parametrically, you can adjust features such as branching, the amount of leaves, and so on, to help you create new, unique species.

The second component is a programming API that handles all the tree loading, LOD handling, and rendering for you. SpeedTree's run-time component interpolates using blending between several discrete LODs that are automatically computed by the modeling tool, and renders the trees as billboards when really distant. The beauty of SpeedTree's approach is that all the LOD handling, dynamic tree lighting, shadow computation and animation are hidden away, so all we need to do is use a simple programming interface to access the tree technology. IDV became popular at the Game Developers Conference this year with a demo showing a 600 square mile, one-million tree forest with shadows and animation in real time on a pretty mid-range PC.

To test SpeedTree RT, we took version 1.5 and integrated it with an existing DirectX project already involving large outdoors scenarios. SpeedTree comes with sample implementations for DirectX, OpenGL and NetImmerse, so all we needed to do was copy and paste from the DirectX examples. Overall, it took one developer one day of work to have our first trees working, and about three days to have a complete version, with trees integrated with the scene graph, the animation, and our collision detection. All in all, the API is simple and well structured, so integration is straightforward. We only found one hangup, which had to do with the way our test engine used fog, and we used this problem to test IDV's customer support. The issue was solved within hours by IDV's people, who provided a tailored version of the shaders used by SpeedTree that supported our fog scheme. We also got Word documents explaining the problem, the solution, and so on. Being a small company, you get direct access to the actual developers, so questions can be answered easily.

The resulting trees are a perfect balance between speed and quality. Seen up close, the trees are remarkably believable: you can look up at the treetop when your character is standing directly below the tree, and the illusion of volume and parallax between the leaves is properly maintained. Additionally, as SpeedTree uses billboards to represent distant trees, creating large vistas with forests is a breeze. Some individual trees do look a bit algorithmic and fractal at certain moments, but when placed in a grove or forest, the results are strikingly realistic: you get animated trees with real-time shadows that you can see far away and up close. Plus, you get the tree editor so you can create new species, via parameters that control things like branching, the amount of leaves, and so on. This helps you create new species so you can build your own, unique trees.

Finally, it's worth mentioning to those familiar with previous versions of SpeedTree that the just-released 1.5 version adds frond support (aside from fixing glitches and improving performance). The new trees have richer, denser branches, and their internal structure just looks more realistic than before. Finally, we found that, using the new version, SpeedTree can create quite compelling shrubs and bushes as well.

Still, great products do not come without minor glitches. In the case of SpeedTree, we felt more code samples would have been a great way to expose all the potential to the user: advanced topics such as shadows on uneven terrain, scene graph integration, fog, and seasonal changes are ideas that definitely come to mind when using this package, and having examples at hand when you feel like coding advanced ideas would be fantastic. That said, the code examples that are provided cover most day-to-day uses sufficiently, from tree loading, rendering, and the setting of the different parameters such as wind, light, and more. Level-of-detail integration is another area where IDV should spend some time making improvements. While trees blend the different LODs quite well, in some cases the transition is too noticeable, and can break the illusion of continuity. Finally, IDV has to be careful with its approach to left- and right-coordinate systems. Currently, both approaches are supported via two sets of libraries and DLLs that are provided to users. In future versions it would be great to be able to define that at run time, so a single interface can handle both left- and right-oriented applications.

SpeedTree can be purchased on a per-project basis, as most game development toolkits out there: $5,995 per title. My suggestion is to download the demos and evaluation version from IDV's website, and estimate how long and how much it would cost to develop a comparable technology internally at your company. SpeedTree combines reasonable cost, short time-to-market and strikingly good results.