Terrain rendering has improved substantially in the last few years, but creating realistic-looking trees is still a difficult problem. This review looks at two popular licensable tree technologies: Bionatics' NatFX and RealNAT, and IDV's SpeedTree RT.
by Daniel Sánchez-Crespo Dalmau
October 01, 2003
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.
RealNAT's
editor, showing the different plant types we
are working on (in the bottom pane).
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.
NatFX
integrated within 3ds max, showing three instances of the
same tree family.
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.
SpeedTree's
tree modeler allows you to create your own species complete
with lighting and animation.
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.
SpeedTree
can create trees of all kinds, from
gloomy (top) to natural-looking (bottom).
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.
Pros: -Generates high-quality trees for cut scenes
- Natural workflow makes the tools easy to use
- Can simulate growth, blooming, seasonal changes, etc.
Cons:
- Developer must handle rendering
- Limited control/
modification
- Two packages to solve one problem
