LOD for GAMMING

Level of Detail (LOD). To reduce the number of polygons that need to be

rendered.

When to use LOD models

It may be worth creating one or more LOD models if your model has:

• small details which increase the polycount but cannot be seen at a distance
• rounded or organic areas using a lot of polygons to suggest 'soft' edges
• physic props - you never know where the player is going to carry them
• expensive shaders (e.g. Normal Maps, Reflective Materials or the eye
shader.)

Some cases in which an LOD model is unlikely provide any noticeable performance
increase:

• your model already has a small polycount or is low detail

• you don't think you can reduce the polycount by at least 30% (the model has
no round/organic features)
• a static model that is only going to be used in areas with a good performance

Tips for LOD Models

The work in the model editor should be kept to a minimum. You don't want to spend
as much time on your LOD models as you did on the original model! Our goal is to
make a few modifications on the model that will reduce the polycount within a few
minutes. However, we don't want to make a whole new model, redo our UV map or
something else that consumes a lot of time.

Get used to the fact that a LOD model can only be seen from a large distance. If a
player wants to see details, he'll step closer. Since the player does not focus on the
details, we can remove them without him noticing if it is done in a subtle way.
Things you don't want to do:

• Changing the outline of the model or anything that gives cover. You can
remove the seats within a car, but don't remove the roof.
• Moving details on the UV map. The texture will most likely get stretched
during the process, however only if details move from one place to another
it'll be noticeable.
• Smoothing groups changing in a way that one large area turns from
shadowed into brightened or similar.

In general, there are fundamental differences between Movie and Game generated
assets. A primary concern is polygon count and efficiency. Currently the only way
to model in video games is by using polygons, which can require a denser mesh to
emulate smoother or more natural looking models such as humans and animals.
NURBS models can be created, but need to be converted and optimized to polygons
for use in the game. In pre-rendered movies, any technique is allowed to create
your models.

Movie models can be generated up to millions of polygons using several different

techniques at once. A model consisting of NURBS and polygons as well as
subdivision surface models is normal and completely acceptable.

Gaming models have to be more efficient in their use of modeled details to maintain
a manageable data set to render. The reasoning here is that an efficient
streamlined environment composed of the lower poly assets will render more
smoothly and give better frame to frame renders during gameplay. What your
gaming system is in essence, is a renderer that constantly has the task of rendering
each frame of gameplay at 30 frames per second. Some games hit the magic
number of 60 frames a second. If this rate drops during the game the result is a
poor experience and hampered gameplay. This applies to PC games as well,
although they will typically have more processing power to run higher resolution
models.

With constant innovations and improvement in next-gen consoles and technology,

development of more advanced techniques and processes give us more detailed
looking models at a lower cost. One of these advances is the use of normal
mapping. A normal map acts like a bump map, in that is adds surface detail
without adding polygons. Normal maps go a step further because they actually
replace the surface normal with new multi-channel data to represent an X, Y, Z
coordinate system. What this means is that we can create a high resolution model
of 2 or 3 million polygons and bake the high resolution detail down to a normal map
that retains the component space data of that high resolution model. It is then a
process to create a streamlined model that emulates the general proportions of the
high density model, but at a much more efficient poly count of 2500, for example.
Once the normal map data is applied to this low-res rendition of our high-res
monster, the model immediately looks more complex geometrically but at an
affordable rendering cost. Movie productions also use Normal Mapping techniques,
but the asset that they use the Normal Map on is typically a more detailed model
than the one used in games.

In this game example, the scene calls for a wine barrel to be created. It will be
duplicated many times in the scene, so it needs to be efficient.
We start by building a low-res model of a few hundred polygons:

Lo-res model*

Then a higher resolution asset is created that has more detail and visual interest.
This model has many more polygons and modeled details, running up into the 10’s
of thousands.

From this higher resolution asset we bake out our normal map and apply it to the
lower density asset. The result is seen here:
Low-res model with Normal Map*

The final in-game asset, completed with a color and specular map, can be seen
here:

Final game render

What we have is a high resolution looking in-game asset that renders like a
low resolution asset.

Another difference between movie and game modeling is the fact that not
everything needs to be built for a movie or pre-rendered model. It is common
practice for film to only build those elements in the scene that you can actually
see on the screen. In a game environment, it is necessary to make most things
viewable from 360 degrees. Can you imagine walking around your favorite game
level and not seeing the back side of 3D car you just walked up to? Or not being
able to see the back of the character you just spoke to? It wouldn’t keep you
immersed in the game very long. Well in a movie if the camera never travels
to the rear of that set or never moves around the corner, it doesn’t need to be
built. This is certainly true for aspects of the gaming world, like the far off detail of
the mountains, or implied buildings that you as a player can’t actually get to in
the game.

A common practice among the two disciplines is that of creating LOD models,
or Level Of Detail models. In a game, when a character carrying a machine gun
walks up to you from the far end of a long hallway, chances are it is not a
consistent model the entire journey for the character or gun. When it is far away,
a lower resolution model, with lower resolution textures is used. The reasoning
for this is that the details cannot be discerned at that length so there is no need to
use CPU time to render those higher resolution elements. As the character
approaches, there may be 2 or 3 changes that swap the model and textures out
with higher and higher resolution assets, until it has walked right up to you in
camera. If done properly, these “swap outs” go unnoticed for the most part.
Here are three LOD models that range from the lowest, to the highest resolution
and density:

LOD examples (all seen up close)

• Now that you can see it up close and appreciate the details, the highest
resolution asset is required here. In a game, these types of LOD model are
used constantly and in varied ways to allow the best frame rate at all times.
Seen up close, the lower resolution models look out of place.
• Looking at them in the context of how far away they would be seen, however,
makes their existence much more understandable:
LOD examples (seen at appropriate distances)

GAMMING QUALITY

LOWPOLY

HIGHPOLY
OUTPUT