You are on page 1of 42


This tutorial is meant to be a step by step guide to the creation of tracks for rFactor.
Please note, it's assumed that you have some basic knowledge of Max and 3D
construction. Even with a “track editor” sort of tool, which would help in the creation of
the racing surface, the objects and props would still need to be constructed in some sort
of 3D package. Thus, track building is a complicated endeavor. If you don’t have prior
knowledge, you should go out and buy yourself a good tutorial book on Max basics and
learn the general function. Even then, keep your first track a simple affair. Use it as a
learning experience...


First things first...set up your working directory. For rFactor, we're going in a little
different direction with our track organization. So, in the “Gamedata\Locations”
directory, you are going to add a sub-folder that should be named after the generally
accepted name of your track. I am going to be using a new track called Nevada Sands as
an example, so thats what our highest level folder will be called. Then, inside there, you
should have four sub-directories: Gmt, Maps, Projects, and Ref. Gmt is obvious, that is
where you will convert your gmts into. Maps is where the textures are kept. (I usually
have a sub-directory in maps called HiRes or Working, which is where I keep the PSD
files of textures I'm using.) Projects is where you keep the max files, and Ref is for all
your reference material.
You can never have enough data about your track. The first place to start looking is to see
if your track has a website. Most reputable racing venues have decently thorough
websites that a the very least have track maps and basic data like track width, length,
banking info (for ovals) and sometimes elevation data. So, that’s first. Also, Google
Image Search is a handy tool...sometimes they will have even more detailed info for you
to find. What you want to do is find the best quality most accurate data to do your initial
track layout from.

In the case of Nevada Sands, my initial concept for it is to be a modern F1 style track
with multiple layouts built somewhere on the outskirts of Las Vegas. So, what I looked
for was images that had the right look I was going for.
Tracks need to be considered from two separate aspects: Visual and Physical

Typically, a track-maker shoots for a realistic look for their track. In other words, if your
screenshots look like your reference photos you are heading in the right direction. Use
desaturation to bring you grass and other textures closer to what you would get in a photo
or on TV. This has the added benefit of helping the cars stand out a bit. The brighter cars
will pop more against the slightly desaturated tracks, as their backdrops, and advertising
and logos will add nice contrasts in these types of environments.

Graphical detail and variety is the second most important aspects to the look of the tracks
next to tone and lighting. Detail should abound from the track sections to the side objects.
These objects should all vary in shape and size. No two trees, billboards, outhouses,
grandstands, telephone pole, etc. should be EXACTLY size. If the polys are there use
them to their fullest advantage. Obviously there are limits to this, but this should be in
your mind the entire time.

The physics of the tracks should be as varied and contain as much contrast as the
geometry and tones of the graphics. The grass should bounce you around and make you
fearful to get off the road. The track surface should have slight undulations while
containing sharp bumps placed manually in the track to add tension and difficulty. The
geometry of the track should be adjusted to give larger bumps in the grass and specific
bumps on the roads. There should be an overtly obvious difference between road
surfaces, grass, and gravel traps.

Most important about the physics of the track is making sure the car flows over the track
surface and through the curves. Understand how the car moves and reacts to the track
surface. Spend time to incorporate this into the track.

Find a good example. Before any track is started, find a photo of a race that you wish
your track to replicate. Use this photo exhaustively as a reference for tone, detail,
lighting, and texture. Bring this photo up and compare it to screen shots to make sure you
are on target. Below is the example used for Toban Raceway Park.
Believe it or not, this is actually one of the most important steps in track creation: the
design of a fun to race on layout. Spend some time on this…no need to rush it. Take
inspiration from your favorite tracks…look how they did things, turns, hills, curbs,
runoffs. No obviously, if you're recreating a real-world track then this has already been
decided for you. But for our example, here is the initial sketch that I did for a test track
for rFactor called Nevada Sands.

In that sketch, I laid out the basic paths of the track, including alternate paths, as well as
put in some elevation notes, and locations for the grandstands. Happy with my initial
layout, I scanned this into the computer.


Begin a new project in 3D Studio Max. The version used for this tutorial is 5.1, but
basically should be the same for later iterations.
Scott's Note: Before doing anything else make sure wing: under “Customize\Unit
Setup” go into “System Unit Scale” and be sure it's set to “1 unit equals 1 meter”.
You can work in either US Standard, or metric, “Display Unit Scale” but the
“System Unit Scale” MUST be set to “1 unit equals 1 meter”.

Now, select the top view, and expand it so that it is the only window. Press ALT+B to
bring up the viewport background window. In the file select box, select the pic of your
layout. Then, click “Match Bitmap” in the Aspect Ratio section, and then make sure
“Display Background” and “Lock Pan/Zoom” to the right of that are checked. Hit okay,
and your layout should show up in the viewport. (Scott's Note: Likewise, you could
create a plane that's size matches the pixel width and height of the image [for
correct aspect ratio] and map the layout to it. The plane can then be scaled to
match the real-world scale of the track.)

At this point, begin to trace the layout with splines. Start by just drawing straight lines,
you can then switch the verts to bezier corners, and use the handles to adjust the lines into
the proper curves, so that you get something like this:

Now, you can tweak the verts and splines to achieve something you’re happy with, and
fix any small issues you can see cropping up already. For example, I needed to adjust my
pit lane because my drawing was a little crooked, and I tweaked the final chicane a little
bit. You don’t really need to put in things like grandstand place holders, as I did…but
sometimes it’s best to so you know where to place them correctly later.

After completing what I thought was a detailed enough layout spline, it was time to scale
it up. For this, I selected part of the spline as a measuring line. For Nevada, I used the
main path, as I wanted that to be a specific distance. (Find out how your track data was
measured, and use that.) Max has a nifty little Utility called Measure. It's found in the
Utilities panel in max. What you do is select a spline, and then Measure will tell you
exactly how long it is. Now, because you'll have multiple splines, what you do is click on
your measuring spline, then click the "Lock Selection" box in the Measure panel. Now,
select everything else, and then scale it up or down using the Transform Type In (F12)
for accuracy until the Measure panel matches your tracks data. Now you have a nice
accurate layout.

So, after scaling, my main layout is 3.8 km. (By detaching and reattaching a few
segments here or there, I can also get a reading on what the other layout is, as well as the
pit lane.) The High Speed Layout clocks in at 3.446 km, with the pit lane being 1.021

Note: if you pre-scaled the layout after mapping it to a plane then scaling the track splines
are obviously not required as they're already to scale....


Here's where the real meat of our work is done:

First, make a box. In length, make it 10 meters. (Generally speaking, we usually work in
metric). So, length, 10 meters. Width...well, however wide your track is. For Nevada
Sands...I’m going to make that 12 meters. Height is are going to
delete one set of verts in a minute anyway....just make it tall enough to register as a box. comes one of the tricky parts, and there's no hard and fast rule. For proper
specular/road glare, the road needs to be subdivided. Typically, I will divide the track
along it's length, and then make cuts along the width to make equal/or mostly square
segments. Use your judgement. The thing to remember is, the more subdivisions you
have, the smoother your road glare will be, but you’ll also be rendering that many more
polys, so you need to find a good compromise. In this case, I will be making it 2 deep by
3 wide.
OK, now that you have your basic box...switch to a top view. In the modify panel,
convert the box into an editable mesh. You can do this by adding a modifier in the drop
down or by right clicking on the word Box in the stack. Switch to the polygon level, and
grab the faces along one side of the box...we're going to be making the road lines now.
Once selected, extrude them to the width you choose.
Then, extrude again...that will be your road-to-grass transition...This is not going to be
very wide...say 0.4 meters. (If you have an apron on your track, as I do here, extrude it's
width and corresponding lines between the track and this grass transition.)

Extrude again...this is your first section of grass, and should be around 3.5 meters.

Extrude again. This is your second section of grass...and this can be any length
really...your choice.

Extrude again. This will become your concrete wall or guardrail. Obviously the guardrail
will be thinner than the wall. Wall is generally around .2 meters thick.

Extrude one more time. This is your outfield grass. Width doesn't matter, you're going to
change it anyways later.
Okay, now switch to a side view, and switch to vertex selection...You should see a box
w/ (at least) 8 sections. Now, grab the verts along the bottom row and delete them, so that
you end up w/ a flat plane.
Switch back to face level, and grab the section that I said was for the wall. Now extrude
this up to make the wall, and then delete the polys on either end of that wall so you don't
end up w/ interior polys upon replication.
Grab the verts between the transition piece and the first grass section and pull them down,
about .07 meters. Then switch to edge mode, switch to top view, and grab the edge
between the transition piece and the road line. Shift copy it outwards to line it up w/ the
other edge of the transition piece, but DO NOT snap it. When you look at this from the
side, it should extend straight out over the transition piece, and be lined up horizontally
w/ the verts you pulled down. What this piece is, you map it with a track-edge texture
that has alpha translucency along one side, so that you get a smooth looking blend into
the grass while retaining the right spec and bump map tiling on both track and grass.
Now, repeat this process for the other side of the track, or in the case of ovals, you can
just shift copy the wall you made onto the other side of the track and snap it into place.
(I've taken to building in SAFER walls on ovals, so they’re are a little more complex, but
hopefully you get the idea.)


One of the big steps towards making a track look realistic is having a number of side
objects that populate the infield and outfield. A number of these can be built in to the
cross-section. Basically, anything that is going to be repeated on a regular or even semi-
regular basis around the track should be put into the cross-section.'s much
easier to move an object or delete it later then to try to make and place a bunch of them.
(Scott's Note: This isn't exactly true, as there are several MAX scripts, such as
“Mouse Planter” that make placing objects like trees, telephone poles, etc. a breeze).

So, fences are a must. Look at your track ref and see how the fences are set up. Usually
there are fences that come up from the outside walls. Often there are another set of fences
past that that act as crowd barriers. Both of these should be built in. Also, fence poles.
We tend to sort of fake the number of poles for framerate reasons...usually, if there would
normally be three or four poles along a 10 meter stretch, two poles will do, and then you
can fake the rest in your fence maps....but having a few poly ones will help w/ the
lighting ambience.
For stock car style ovals....I usually build in the MUSCO lights that ring the inside track,
as well as their glows. There are a ton of these, and need to be regularly spaced out.
Whatever you can think of to include here at this point of track creation will make your
life much easier in the future. Here is a pic of my final cross-section. I didn’t do a lot
here, because I plan on adding things more on the fly, but you can see I added a little bit
of angle to the outside of the concrete walls and then put in fences and polygonal fence


Ok, now, before we start adding textures, there are a few terms we need to get straight, so
we don’t have any confusion:

Texture: A texture is an image file that is applied to the 3D mesh. This can be a regular
bitmap or targa used as a base map, as well as auxiliary images used for bump, specular,
and cube maps.
Shader: A shader is a piece of code that tells the engine how to combine certain maps to
achieve certain effects. You can have different shaders for DX7, DX8, and DX9, and
often must.

Material: A material is a combination of textures and shaders that acts as a single entity.
For example, a typical road material will have a base map, a bump map, and a spec map,
for the DX9 level, as well as an additive and a multiply map for DX7 and 8, which use
different shaders….so the road material would be a combination of 5 textures and three

Now, onto the multi-sub.

Open the material editor. It looks like this:

First, create a multi-sub object by clicking on the material type button and selecting
“Multi/Sub-Object”. You will get a default multi-sub material with 10 sub-materials.
You can and will change the number to as many as you need, but 10 is fine to start with.
At this point, you should name this multi-sub something, like “Track” or “NevadaTrack”.
Now, click the first sub-material…it’s time to make a road mat.

Click on the box that says "Material" in the upper/middle right. Change it to
gMotorMaterial. You must do this for every material you want to use. Once you change
that, the rollout will change to the gMotorMaterial setup.
In the box that says shader, pick DX9. (It's best to start at the top and then import your
settings to the lower DX levels once you have them set up.)

We're going to be doing the road texture first. So name your first material something like
ROADA or ROAD01. This is because the terrain.tdf file that governs HAT physics looks
for specifically named materials to correspond w/ the terrain data. (Unless you're using a
track specific tdf file...see Joesville for an example.)

OK, the road. We're working in DX9, so pick the Bump Specular Map T1 shader in the
shader drop down menu.

Also, at this point, set your specular color to pure white, and your specular power to
somewhere between 4.0 and 15 (experiment w/ it...higher spec powers focus the road
glare more.) (Scott's Note: I've never used, nor needed, a value higher than five.
Also, lower values with dark spec color will give you a smoother glare while using
less track segments in DX7 and DX8. Lastly, don't be afraid to add a bit of color to
your spec color [rather than grays] to give your glare a warmer or cooler tint)

Assign your multisub to the track piece using the Apply Material Button. (If you haven’t
applied any UVW Mapping modifiers, the track object will turn all grey. If you have, it’s
probably mapped with random textures at this point.)

For this shader, you're going to have three maps. The first is your base map...this is where
the color of your road comes from, as well as some basic details like cracks or what not,
and is tileable in one direction. Your second map will be a bump map, and your third map
will be a spec map, both of which you should be able to tile seamlessly in both directions
(x and y). The spec map is an important map, because that is where much of the road
detail and all of glare will come from.

Stage one is the base map. This should be mapped one to one using the UVW Map
modifier on a face level. NOTE: Do not use the tiling values in the material editor.

Now go back up to the material level. Click on the next stage, which is the specular map.
Assign the spec map in the texture box. Now, and this is the coordinates
rollout, change the map channel to 2.

Back up to the material level, pick the third stage. This is the bump map. Assign your
bump texture, and change the map channel to 3.

Now, time to learn a nifty trick. You've already mapped your base texture 1 to 1. In the
mat editor, set the spec map to be visible in the viewport. With your road faces selected,
apply a UVW Map modifier and in the modify panel, where it says map channel, change
the number to 2. Now you are only mapping the specular texture map stage, while
leaving the mapping on the base texture tile the texture to get a nice tight result.
Follow this same process for the bump map, but use channel 3 instead.

The reason we do it this way is this...for your base textures (i.e. different road surfaces,
road lines, ect.), you need to map them specifically, usually 1 to 1. But you are going to
want to map the spec and bump across all your road polys now you
can grab all the faces you want to map, then do a UVW Map only on channels 2 and 3,
and that way get seamless tiling across multiple materials.

This technique made one of the biggest differences in our track creation process, and led
to much more efficient texture management and usage.

Now, on to DX8. Simply select DX8 from the drop down menu and click on the Copy
DX9 button. This will copy all of your DX9 textures and settings into DX8. (Note that
sometimes it may not be a good idea to do this, as there may be better DX8 specific
shaders for what you want to accomplish in 8.)

Because DX8 and 9 use advanced shaders, you must set up a more rudimentary system
for those with lower machine specs running DX7. Start by switching to DX7 in your
shader level drop down. For the shader, pick T1 mult T2. This shader will use a separate
multiply map in conjunction with your base map to produce the road texture.

Now that you have your road mat squared away, you can copy this material using drag
and drop to make copies. Use this to make the mats for your road lines, transition piece,
and if you have one, the apron.

In regards to the transition piece. This material should be a copy of another material, but
with alpha translucency settings for the fade. For Nevada Sands, because the transition is
part of the red apron texture, I made a copy of my ROADAPRON material, named it
ROADAPRONTRANS, and then set the Alpha Blend settings to Src Alpha and Inv Src
Alpha. This will now use the alpha channel in the texture to do the texture translucency.
Moving on, this is the area that will be mapped w/ grass, or, in this case, dusty sandy
ground. Whatever your texture, these six polys, and their corresponding six on the other
side, are your grass textures.
The shaders to use are as follows:
DX9: Specular Map T1 mult T2 add T3 (4 maps)
DX8: T1 mult T2 add T3 (3 maps)
DX7: T1 add T2 (2 maps)

As with the road, make use of the multi channel mapping so that you can apply UVW
coordinates to the different stages independently of each other.

I’m going to skip the step by step for the walls and fences…nothing tricky there really.
Walls I used a Bump Specular Map T1 shader, and don’t forget to add the alpha settings
to the fences. Here’s an ingame viewer shot of my cross-section:
(Scott's Note: Something to keep in mind: Multi-Sub material balls with several
sub-materials will bog MAX down. So, rather than using 1 Multi-sub for everything
that contains 100+ materials you'd be better off using several multi-sub's with 30 to
40 materials-ish. It'll keep you better organized, too, as you can separate the multi-
sub's into track, vegetation, buildings, etc.)


This is a fairly easy step in the overall process. The array function is used to make many
uniform copies of the same object…in this case our cross-section. It is found in the Tools
section of the menu bar. Make sure you have your cross-section selected, and then open
the array box.
The first part is the incremental. This means where, from your original object, do you
want to create the next one. Since your cross-section is 10 meters long, you’ll put 10
meters here. X or Y depends on the orientation of your object. Since mine is aligned
vertically in the scene, I’ll be using the Y axis, but I will put in –10.0 meters, because I
want the pieces to be added in a downwards direction, to follow the direction of my track.
A positive number will create the copies upwards.

Count is how many objects you want to create. What I usually do is make about 9 copies
initially, and then join them together to make a 100m piece. (Note that setting the
number here to 10 will only make 9 new copies, because your original copy is included in
the 10 count.) I can then add little imperfections to that piece to make it a little more
realistic, and play with the mapping a little bit. Usually I remap the base maps for the
road or the grass, so it covers more distance and doesn’t tile as much.

Under type, you want to make sure this stays on copy, so that each track copy is a unique
object and not bound to any others. So go ahead and array out to 10.

You now have 10 identical track pieces. What I usually do is make one more copy by
shift copying, and then putting that off to the side as an original reference copy, and name
it like that. Then I attach my 10 copies together to make a single 100 meter track piece. I
find it’s just easier to work that way.

Now, what you do next really depends on the type of track that you are making. There
are three basic scenarios that I’m going to cover here, road courses with elevation data,
road courses without elevation data, and ovals.


If you are fortunate enough to find good elevation data for your track, you’re in luck…it
will make your task at hand much easier. What you need to do, if it hasn’t already been
done for you, is to plot out the data into a spline that describes the data as if the track
were unwrapped.

Take this spline and scale it up along so that it is the proper length of the track, and make
sure the height data scales properly as well.

The next step is to make enough copies of your track piece to cover the whole distance of
your track…it should match the length you just scaled your elevation data up to. You can
use array to do this.

Switch to a side view…you’ll have something like this:

Select all your track pieces and apply a FFD Box modifier. This is found in the modifier
list under Free Form Deformers (FFD). You will get an orange box around your track
objects, with four sets of control points. Obviously that is not enough, so in the modify
panel, click on the “number of points” button in the parameters rollout. Change the width
number to something that will give you a good amount of points to work with…your
number will vary according to your track. I picked 30. Hit ok, then make sure that
Lattice and Source Volume are both checked, as well as “All Vertices”.

Go to the sublevel of the FFD modifer and choose control points. Select the SECOND
set of points on your track, and move them down to meet the elevation spline. Continue
this for each set to verts, except for the last set, because when you bend your track, you
want those verts to meet your first set at the same elevation.
Once you get through your elevation…then it will be time for bending. But be sure to
check out your track in the viewer, to make sure you are retaining the smoothness, other
wise you’ll have to go back and fix those areas.


Doing elevation without elevation data is done by the same process, it’s just not done
over the scale of the whole track. Just do the elevation on one piece of track at a time,
and then do the bending, then do the next piece, and so on and so forth. A little more
time consuming this way, but the result is the same.


Here’s where a good chunk of the meat of track building is located. Bending is done
from the top view using the Bend modifier found in the Parametric Deformers section of
the modifiers menu. Begin by applying the modifier. You will notice an orange box
appear around your object, and an orange center point in the middle of it. Now lets look
at the Bend parameters:
First, you have angle and direction. Angle is pretty self explanatory, and direction you
won’t be using. Bend axis is, obviously, the axis you want to bend around. Usually this
is Y. Limits…these are important. First, check the box…by default limit effect is off.
Upper and Lower limit, which one you choose depends on the nature of your bend, but
basically what it does is limits the bend to a certain distance from the center point of the

Also of note are there are two sub objects for Bend in the stack, center and gizmo. Center
is the center point of the object. This is where the bend will be focused around…so move
the center point to where you want your bend to start. (It helps a lot if you only move it
on a local axis.) Gizmo is the box that is surrounding your object. (Sometimes you will
need to rotate this box 90 degrees in order to orientate your bend modifier correctly…so
if you’re getting weird results, like the track is spreading out like a fan instead of
bending, then rotate the gizmo.)

Using a combination of moving the center point, adjusting the angle, and changing the
limits, bend the track piece to match your layout.
Continue doing this for the rest of the track. Sometimes, if there is a particularly tight
turn, like a 90 degree or a hairpin…you may need to go into your track piece and sub-
divide some of the faces to make the bending area bend a little smoother.

Eventually, you will have a complete racing circuit, as shown here:

Notice that I have a portion of the track centered at the 0,0,0 mark. This will be
important later, when you go into real time.


In order to view your track in either the viewer or the game, you must convert the 3d
geometry into GMotor Tristrips, or gmts. This is done w/ ISI’s proprietary plugin
converter for 3D Max. Lets have a look at it.
As you can see there are seven rollout panels in the converter. We’ll start at the top with
main control. This panel is used to actually do the converting. First things first…type in
a name for your configuration. As you can see here, the config was for Sardian Heights
Long…but I typed a new name in here for my new track, Nevada_Sands. At the top
there are three check boxes, along with corresponding buttons. Make Mesh File and
Make Scene File do exactly what they say they do. (Keep in mind you must setup paths
in lower rollouts before you can convert.) The check boxes are for multitasking. For
example, as it is shown in the picture, if I hit the “Do All” button, it will perform all the
checked tasks. Right now, Make MAS File and Activate Tex are unsupported, so ignore
those for now.

Open the GMT Output rollout.

This is where you determine where your gmts will go. Mesh directory should be synched
up with the gmt directory you created in step one.

Quick scene is a handy feature that is new to gmotor. Checking this box will create a
quick scene file in a directory you determine, and hard code direct paths to all needed
assets. This is valuble for looking at a single object, or a few objects without disturbing
the rest of your scene file. It’s good for working on quick fixes, as well as helpful in the
building of vehicles.

Tristrip/Trilist. You want to have TriList checked, and the number 4096 in Max strip

The Do Mesh button here is a duplicate of the one in Main Control.

We’re going to skip Instance for a moment and head to Scene File Output.
There is a lot to take in here. The Scene file is what defines what a track’s assets are,
which ones it needs, and where to find them. It also defines the FOV of front and rear
views, as well as fog values.

First, set up your scene file. This should go in your RACE directory, not your track
directory. In my case, I created a race folder in my Nevada_Sands directory, and called it
Las_Vegas_GP. Inside that folder will be the scene file, Las_Vegas_GP.scn.

In fog, the values are pretty self explanatory. You have in and out values, and the color
swatch is for fog color. You should check active, and linear.

Views: The first section is your main view. N and F are your near and far clipping
planes. Near should be .05. Far is track dependant…experiment. W and H are width
and height…it’s a ratio, so these should be 1:1. The second section is the rear view. First
check the box to add the rearview to the scene file, then set your N:F values to
0.05:150.0, and your W:H settings to 1024.0:64.0. The latter corresponds to the
size/shape of the mirror map in commonmaps.mas. You should check “clear” for
both…this clears the background out of leftover rendered objects. Color swatches should
be a sky bluish color.

Header, Lights, Objects, Cameras should all be and remain checked. The All or Selected
is an option for converting. If All is picked, then when you make a scene file it will
include all objects in the scene. If Selected is picked, then only what you have selected at
the time of conversion is put into the scene. I normally use selected.

Root path should be wherever your root rFactor directory is located.

Search Paths should point to all directories that are calling files that you are using, i.e.,
Maps, Gmt, ect.

MAS Files, when you make your final scene for running ingame, and mas up your files,
you need to tell the converter which mas files to include. You do that here. Keep in at a
certain point, Search Paths and Mas Files paths will conflict with each other, and you will
need to comment one or the other out in the scene file, or take it out of the list here.

And that’s the scene file window.

The Instance rollout is what is used to apply specific attributes to a gmt object. You start
by selecting an object in Max, and then pressing the Get Selected button. This will un-
grey the instance panel and show the default properties of your object.

In the Object section, you will see first the name of the object, followed by LOD values.
Play with these until you get something your are happy with. And keep in mind that in
gMotor 2.0, LOD values are burned into the gmt, they are no longer editable by hand in
the scene file. Following that are a number of checkable options, Collide, HAT, Stamp,
Move, Deform, No Render, No Clip, Billboard, and Localize.

Collide and HAT are the to biggies here, as they effect physics. Collide goes on things
you want to come into contact with, HAT things you want to drive on. For example…a
track piece gets tagged with Collide and HAT, because often walls are connected to it.
But if you have something like a stand alone wall, tire barrier, or something similar, you
would only tag it with Collide, because you don’t want to be able to drive on it. Move is
another important one…anything that is going to move in some way shape or form in the
database needs to be tagged with move. No Render is used for things like invisible
walls…you still want to interact with them, you just don’t want to see them. No Clip is
self explanatory…those things won’t be clipped by other objects. And Billboard makes
things always face towards the camera….it, along w/ deform and localize, is not
something we use a lot of lately.

Next you have a choice of normals to use. Always use gMotor normals, with the
exception of things like trees, then you want to Use Pointy Normals. This is to help with

Both vertex tolerances should be set to 0.0.

There are three types of shading, None, Flat, and Smooth. None is obviously no shading.
Flat is to be used for objects like buildings…things with sharp, distinct edges. Smooth is
what you will use mostly. You can only pick one of the three.

Shadows, also three options, Object, Caster, and Receiver. If you tag something as a
ShadowObject, it will not render, but will cast a shadow. Use this to make low poly
shadow caster objects for things with more complex geometry, like grandstands and
garage buildings. Caster is for things you want to cast shadows, and Receiver is for
things you want to receive shadows. Selecting Object or Caster will bring up the shadow
attributes box. Here you can use the sliders to pick the size of your cast shadow map, as
well as pick either texture or solid casting. Solid will make a solid shadow, where are
texture will take into account the alpha channel of the texture map to make it’s shadow.
Stuff like trees are tagged with texture casting. It’s much more expensive than regular
solid casting, which is not cheap to begin with.
Other: The big one here is Omni. You want to tag this onto objects that will react in any
way to omni lights. (Scott's Note: In rF, taging something as “Omni” also allows it to
accept car headlights)

The next section is vis groups. The first and most important thing to realize is that VIS
groups are setup NOT TO LOAD. So VIS groups are not to say what is in the scene but
rather what is NOT. So keep that is mind. This list is just a general idea of how to set
them up on a track. Use good judgment on whether or not this exact pattern is good for
your track. We must be close though so the user gets an anticipated result from track to

There is 4 detail settings in the options: (descriptions of each VIS group will be given
Full = no VIS groups are turned off
High = VIS group A is turned off
Medium = VIS group A and B are turned off
Low = VIS group A, B, and C are tuned off

That is the basic setup for VIS groups.

A = everything that you want removed for High detail

In VIS group A I included the least important objects on the track, these are
objects that can be removed because they are not important and can reduce the poly and
texture counts. Objects included are: out houses, camera stands, speakers and poles, the
second layer of double layered trees, all the seats put in the bleachers, misc small side
objects, and maybe a few back ground buildings that are there just for parallaxing.

B = everything that you want removed in addition to VIS group A for medium detail

Remember everything in A is turned off as well. Vis Group B includes a

selection of objects that are high poly counts and are highly visible as you drive.
Objects include transparent skids on the track and start grid, jumbotrons, cranes, most
side buildings, some grandstands and bleachers (and their associated people, all trees that
are not connected to or will cause big holes in the track, and if you have one it... the sky
fade in the sky box, and some fences.

C = everything that you want removed in addition to VIS group A and B for low detail

Remember that everything in A and B are turned off as well. This VIS group is
the last resort. Most everything else must go... A few exceptions to keep in mind.
Anything that includes or is attached to the starting lights must stay. Most Billboards can
stay, you can get rid of a few if they are complex but please leave the majority on the
track (good visual reference at not much cost). Also turn and brake signs must stay. One
more exception is the pit buildings they must also stay. Bear in mind that you still do not
want to have giant gapping holes in the outside database even in the lowest of settings so
keep in the objects that block the holes as well. Objects include the rest of the
grandstands (and their associated people), all buildings, all trees, bridges( and there
shadows), all shadows, all camera stands, most transparent fences (keep some for
diversity and if they are attached to the wall), the rest of the people who are not in any
bleachers or not removed in an earlier VIS group, anything else loose you still have

The next two VIS groups are a bit complicated but are there if you have the time to use
D = High detailed objects that you want to replace with low detailed object form VIS
group E
E = Low detailed objects that you want to replace the objects in VIS group D with

This is setup so that when a user selects Low detail D will automatically be turned
off and replaced with E. If nothing is tagged with either, nothing will change. It will
then work just as above A-C.

F = Extra objects that you do not want to be in the rear views.

Basically you want everything OTHER than the cross-section of the road and the
pit buildings in this VIS group. So those are the only things other than the cars rendered
in the rearview. Objects include outside geometry not connected to the track, startlights
and associated bridges, all billboards, all buildings, all trees, all brake signs, all
shadows... etc...

G = Everything you want to remove from the practice session

Granted there is not much other than most if not all people you want to remove
from the practice session but it will allow you to get rid of special case objects like
grandstands that only appear in race mode so they can be replaced in practice mode with
objects with no people mapped on them.

H = Everything you want to remove from the Qualifying session

Use this to remove some of the people and perhaps the objects that you only want
to appear in Practice mode.

I = Everything you want to remove from the race session

Not much will be removed from the race session. If you have any objects that are
just for Practice or Qual mode than this is the tag for them.

(Scott's Note: Some “newer” visgroups:

J – Stuff to be turned off at night.
K – Stuff to be turned on at night.
M – Stuff to be hidden during Warm-Up session)
You can skip the Animations section for now as it’s not currently supported. The Reactor
section is a special case. They only thing it is used for is to create the checkpoints for
timing. We’ll cover that soon as we get our track ingame.

So that’s the converting in a nutshell. The MAS File Output, Group, and Animation
rollouts you don’t have to worry about right now.

Go ahead now and convert your track. You can then look at it in the viewer.


The skybox is a combination between two separate objects…the background plane
object, which needs to be named skyboxi.gmt, and the cloud dome, which serves as the
actual sky. Begin by making a cylinder. The number of sides depends on you, but
generally a good number is 16 sides. The radius of your cylinder should be about 550
meters, and the height around 35 meters (to start…you can adjust this later as you see fit
and your track dictates.) Name this object “skyboxi”. Now, delete the end cap polys,
grab all the faces, and flip them so that they face inwards. Your next step is to make a
background image that you can map seamlessly to the inside of the skybox. Once your
skybox is mapped, do a Get Instance in the converter. Take off Collide and HAT, and
turn on Move.

For the cloud dome, you need to make a half sphere, squash it down, and then flare out
the edges. Name it Sky. It too must be tagged w/ Move, no Collide, no HAT. You must
also Select and Link it to the skybox. You do this by using the Select and Link icon in
the main tool bar. This will set the Sky as a child of the Skybox, and allow them to move
around together.

The important part for skies is the material. Go into the material editor. Create a new
multisub, with at least two materials. Make the first one your background texture that is
applied to your skybox. The second will be your cloud material. The cloud material
must be named sky. You only have to set up a DX7 level material, and the shader you
need to use is T1 lerp T2. You need to have 5 sky materials, named sequentially sky00
through sky04. Check the No Compression and No Detail Reduction options. Then go
down to animation. For source, select Texture Maps. Now go to Animation Data. In
name, type in Sky.tga. Type 5 in frames (this corresponds to the 5 sky textures. Check
the Manual option, and then enter this in sequence: (0,0,1,1,2,3,4), with parentheses. And
that’s it. You skybox is done.


Checkpoints are non-rendered polys on the track that the game uses for timing and
scoring purposes. There are five of them, and MUST be named specifically:

XFINISH: This is the start/finish line. It must also cross through the pit lane as well as
the track.
XSECTOR1: Your first sector. If actual sector information isn’t available for your track,
just divide it into thirds. The sector1 poly would represent the end of the first
third/beginning of the second.

XSECTOR2: Your second sector….where the second sector ends, third begins.

XPITIN: This poly needs to pit at the entrance to the pits. It should be placed where the
speed limit comes into enforcement, because this poly will be responsible for monitoring
that, as well as activating the auto-pit command.

XPITOUT: The pit exit. Should be placed where the speed limit ends.

A checkpoint should consist of two polys very close together, facing opposite ways.
They must be mapped with a multisub and have UVW coordinates, but it doesn’t matter
which one, because they’re not rendered.

The important part, what makes a checkpoint a checkpoint, is how you tag it. Select your
XFINISH object, go to the converter, and the instance rollout and do a get select.

In the top part of the Instance rollout, leave collide on, since you want the car to react to
the poly, but take off HAT. Then tag No Render on. Scroll down to where it says
Reactor. Click on Collision. Where is says Actor, type VEHICLE, and where is says
Response, type TIMING. Then hit Add. Repeat this process for your other two sector

For the the pit xpolys, instead of tagging them with VEHICLE, TIMING, you need to tag
them with VEHICLE, PITSTOP. So pick Vehicle from the Actor drop down, then type
PITSTOP into the Response field and hit add. Now your checkpoints are done, and you
should have a working track.


Time to fire up the AIWEditor and get your track in the game. (Remember that you’ll
need a corresponding gdb file to go along with your scene file in order for your track to
show up in the track select.)

Head to a test session, find your track in the list, and load it up.

With no existing aiw file you may receive a couple errors—just ignore through these.
Now you should be able to enter real time on your track, with the car starting at 0,0,0.
(Scott's note: Be sure there is a collision HAT surface under the car at 0,0,0) When
you enter real time, the AIW editor should already be up.

Lets go through a quick and dirty version of setting up AIW stuff. First, lets get a pit
location and garage location in. Press 3 to enter the pit location menu, press 1 to add the
first pit location, and then 0 to exit that menu. Back in the main aiw menu, press 4 to
enter the garage location menu, 1 to add a location, and then use the mouse to exit the
menu and go back to main. Now save the waypoints. This will create a new AIW file.

Now you can make a path. Press 1, and you will automatically start recording a path.
Now drive a path around your track. You will see the waypoints being dropped behind
your car. Drive the complete circuit, and then when you get back to where you started,
aim for the first waypoint you dropped. The path will automatically close, and you will
be asked what kind of path to make it. Select new Main Path.

Now, head back around to the pit entrance. Make a new path, and drive your pit path.
Start far enough back on the main track where cars would break off to head into the pits,
and end where the cars would rejoin the main path. Press 1 to stop recording a path when
you get to the end of the pit, and mark the path as the 1st pit lane. Return again to the
start of the pits, and use the mouse to select the first waypoint of the pit path, and the
point on the main path you want the pit lane to branch off of, and then join these together
as a branch, which is option 5. Then go to the end and do the same for the pit exit. Now
save your waypoints. You now have a functional AIW path. At this time you can choose
to find corridors, which is the code looking around and determining which parts of the
database are roads, off road surfaces, and walls. This will take a while and it will look
like the computer has locked up…just let it go. Once it’s finished, save again and exit the
track. (Note: After moving walls around and/or altering track geometry, you should
always re-find the corridors.)

(NOTE: When issuing commands in the AIW editor, it’s often easier and less error-prone
to pause the game while you do it. Also, while the game is paused, you can use LEFT
SHIFT+CTRL+Arrow keys to move the car around, and while paused, this does not react
to HAT or Collide, so you can phase it through walls and such. Adding ALT to the key
combo lets you move the car rapidly.)


Well, what comes next is up to you. It’s your track. Once you get things running in
game, it’s time to go back and fill in the rest of the track geometry. Peruse your reference
with a fine tooth comb and get the most out of it. There are a lot of high resolution
photos available on the internet that you can use to make textures. Think outside the box.
If you can’t find a suitable concrete texture in your reference, you can make out of other
resources. The important thing is to make the track look right, but more to the point, feel
right. You don’t have to get every tree perfectly, but try to get important ones in. Decide
what trackside geometry needs to be built in high detail, and what doesn’t. The closer to
the track, the more high profile an object, the more detailed it should be modeled.

Currently gMotor 2.0 does not support animations. However, we do have a rudimentary
function to program rotational animations in using the naming conventions of a gmt.

What you need to do is name whatever you want to rotate something using this
convention: RotateY10_blahblahblah.gmt. Rotate must be the first word in the name.
The letter following that can be x, y, or z...this defines the axis of rotation....for
scoretower toppers that would be Y. The number following the axis is rotation speed.
I've found that 10 is a good speed for the logo boxes at the top of the towers. After the
speed number...there must be an underscore. Following the underscore can be doesn't matter to the code.

Objects that are going to rotate must be tagged w/ move in the converter.

Now...a note of distinction. The code works on an instance level, not an object level. I
told you to name the objects that way, but just so that it will be easier to convert out...the
instance will already be set up for you that way. But you could just as easily go into the
scene file and edit the Instance=name by hand and it would still work.

Lights that are used to light up the track at night are done by placing omni lights in max
where you want an area to light up. Use the max range and intensity to adjust how much
distance you want lit up and how bright you want it. Keep in mind that you can only
have 4 omni lights per instance…so break up your track pieces accordingly. If you want
the lights to only come on at night, then they need to be named NightlightXX, where X=a
number. Now, if you want to have corresponding glows for your grandstand lighting or
Muscos or whatever, they must be named NightlightXXglow.gmt, and must correspond
to an omni in the scene. Example: If you have a glow object named
Nightlight05glow.gmt, there must be a Nightlight05 omni in the scene, or it will not

Omnis do not have to be night lighting though. You can use them in other ways, like to
light up the inside of a tunnel, and you can change the color of the light they give off by
using the swatch color in the omni modify panel.