From Bitmap to Boom-and-Zoom in 60 Minutes

Viso's Aircraft Tutorial for Gmax
Viso's Vehicle Tutorial for Gmax

From Bitmap to Boom-and-Zoom in 60 Minutes: An Overview of gmax Aircraft Design and Flight Modeling for CFS3 By Craig "Viso" Murray Last Updated: 05-Sept-2007 Send an email to Craig Introduction The Three Main Stages of Aircraft Modeling A Crash Course in Aircraft Modeling Building an Oversimplified Aircraft in 60 Minutes Building Your First 'Real' Aircraft

	Aircraft Selection Diagram Preparation Basic Shaping Control Surfaces Details (Props, Lndg Gear) Cockpits Armament	Keyframe Animation Damage Boxes Endcaps Emitters Hierarchy Texture Design Texture Mapping	Exporting to CFS3 (and CFS2) Flight Model Damage Workbook Modifying XDPs Flight Testing Packaging

In Conclusion

Introduction

An Introduction to the Overview
If you're like me, you've been playing Microsoft Combat Flight Simulator in its various forms for years. Along the way, you discovered the fun-filled world of downloads (aircraft, missions, campaigns, other bits) and you've come to realize how easily the CFS3 universe can be expanded. Now, you've decided to make a contribution back to the CFS3 community by building an aircraft.

Congratulations.

But how do you get started?

There are plenty of good tutorials on certain aspects of aircraft building already out there, and I highly recommend many of them. However, getting started can be a struggle if you don't have a good overview of the entire process. I'm what you might call a 30,000-foot kind of guy. First, show me the forest and then we can talk about the trees. Once you understand the entire process, I think you'll find it easier to tackle each stage.

In the pages that follow, you'll get a quick overview of most of the process by building a working aircraft in gmax that will fly in CFS3, complete with virtual cockpit, guns, and a bunch of other stuff. If you have obtained all of the required materials (see below), you can skip ahead to "A Crash Course in Aircraft Modeling " right now.

I started building aircraft with gmax in October 2004, so at the time of writing the first version of this overview (December 2004) I had only been at it for two months. However, those two months were (for me) a daunting "tree-to-tree" battle of trying to pick my way through the forest. It was more than a little discouraging but, thanks to the patient assistance offered through many of the CFS3 forums, I think I've figured out the basics. You won't be an expert by the time you've worked through this overview, but you will understand enough to get started.

I hope you will find this helpful.

Acknowledgements
The CFS3 community is an extension of the broader flight simulation community. Of the CFS3 aficionados, there are many who have made hefty contributions back to the community, thus ensuring its success. Herewith, I'd like to recognize a few of them.

The many websites that provide add-ons, forums, and other resources for CFS3.
The many individuals who share their experience by giving good prompt advice through the on-line forums.
The many individuals who have created and shared new aircraft, vehicles, scenery, campaigns, missions, and other bits and pieces.
Those quiet heroes who support their favourite CFS3 websites financially.
Jerry Beckwith http://www.mudpond.us/ for sharing the Flight Dynamics Workbook.
The Aviation History Website http://www.avhistory.org/. This group has set the standard that flight models should perform within 1% of historical parameters.

If you, dear reader, find this overview helpful, please consider making a contribution of your own to the community, whether financial, new aircraft, participating in the forums, or whatever.

What Equipment You Will Need
You don't need much horsepower to do this. My first computer was a Celeron 600 with 256 MB RAM running Windows 98(SE). Yes . . . I also played CFS3 on it. Stop laughing already, I upgraded it in 2007.

http://www.turbosquid.com/gmax

gmax12.exe (I'm using version 1.2)
gmax12_help.exe (Optional: Download it if you find help files useful.)

http://www.microsoft.com/games/combatfs3/

Aircraft, Vehicle & Building SDK v1.5
If your version of DirectX isn't up to date, you might want to bring it up to speed.
Don't worry about the .NET environment unless you want to create Mosaic files (which aren't addressed in this overview). One requirement for MOS files that is often forgotten, besides .NET and DirectX 9, is Managed DirectX which allows .NET applications to talk to DirectX. The package is called mdxredist.zip and you can either Google it or get it here

You'll need a graphics program. Use whatever you're comfortable with. I use MS Paint (which comes with MS Windows) and Adobe Photoshop to create textures and a shareware version of Paint Shop Pro to handle resizing and screen captures. Anything will do, as long as you can create BMP images.

http://www.mnwright.btinternet.co.uk/index.htm

DXTBmp. This will convert BMPs into (and from) those DDS files.

http://www.avhistory.org/

Read through the various documents.
Note the locations of the Piston Engine Parameters and WW2 Gun Parameters. You can use these when configuring your aircraft.

From the CFS2 1% Downloads:

1% Flight Test Airport (Note: this is now available at http://www.netwings.org/library/Avhistory_CFS2_Aircraft/

From the CFS3 1% Downloads:

1% Guns/Weapons

From the CFS3 1% Downloads - 1% WW2 Fighters - Britain section:

The Hurricane Mk IA (3gb_Hurricane_mk1a.zip) with the flight model by Bill "SPITFRND" Wilson. I'm partial to early-war aircraft and I've always liked Hurricanes. Also, this file includes a recent version of the Damage Worksheet.

If you didn't download the Hurricane above, then you'll need to get the Damage Worksheet, named "AssemblyLineDamgeV2.32, from somewhere else. Often, this can be found (in various versions) with other 1% downloads.

For precision flight testing, you'll want to scrounge an old copy of CFS2. That's because there are some tools that only exist in CFS2.

From the Jerry Beckwith's Mudpond Virtual Aircraft Development Center, http://www.mudpond.us/

Flight Dynamics Workbook (FlightDynamicsWorkbook.zip)
Air Update Utility (AirDat.zip) for creating .AIR files.
CFS2 Flight Test Gauge Sets (click on the gauge picture to find the link). Unfortunately, you'll have to do some of your testing in CFS2.

I suggest that you make printed copies of the following tutorials, to which I will often refer:

Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax" at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.
Darren Brooker's "gmax aircraft tutorial" at http://www.aerodynamika.com/gmaxtut/gmax000.htm.
Check out http://www.freeflightdesign.com/. They have an extensive list of tutorials, tips, and other resources.

Lastly, you'll need a good amount of patience.

The Three Main Stages of Aircraft Modeling
In my humble opinion, any good process, master's thesis, sermon, hockey game, or whatever can be broken down into three separate stages. Here are the three stages of aircraft modeling, as well as the corresponding steps within them:

Stage 1: Aircraft Selection: The choice is yours. However, I will suggest several factors to consider when deciding which aircraft to build.

1. Aircraft Selection

Stage 2: Model Design and Texturing: Most of the Internet tutorials deal with gmax design and texturing ("painting"). Here are the major steps involved. We'll breeze through most of these steps in the 60-minute tutorial.

Stage 3: Flight Model: This last stage will ensure that you aircraft flies as realistically as possible. After all, a B-17 bomber that can turn inside of an A6M2 Zero fighter isn't very realistic, is it? Fair warning, this will involve several more hours of flight-testing. However, you will already be investing many hours in gmax, so you might as well take it all the way. Here are the critical steps involved:

A Crash Course in Aircraft Modeling
Folks, this ain't going to be pretty. We're going to throw together the world's ugliest aircraft in one hour (your time may vary . . . upward . . . substantially) AND we're going to make it fly. In doing so, you'll become familiar with the key steps.

By the way, I've capitalized most of my object names to avoid confusion between '1' (one) and 'l' (as in lift). However, capitalization is not required. Also, if you get confused and need more help, refer to the appropriate section in the latter part of this document.

Building an Oversimplified Aircraft in 60 Minutes (or so)

"Borrow" an Existing Aircraft Model	Assuming you installed the Hurricane that I recommended, look in your aircraft directory and locate 3gb_hurricane_mkia. Open the model directory. Make backup copies of all m3d files in this directory. (A simple copy-and-paste will do the job.) Please note that you will use the Hurricane's flight model as a temporary measure only. Under no circumstances should you distribute this flight model with your aircraft. Later on, I will show you how to create your own flight model.

Configure gmax	If you haven't already done so, make sure that gmax is configured so that 1 unit = 1 meter. Configuration instructions are included with gmax or you can refer to Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax" at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.

Create the Dimension Box	In the TOP view, create a box using the keyboard with dimensions of 16w, 12l, and 3h. Name it Dimensions. You'll use this box to size your aircraft correctly. When you've built the fuselage and the wings, you can delete it. Zoom extents in all views.

Create the Fuselage	In the FRONT view, create a cylinder using the keyboard with dimensions of radius=1, length=12. Name it Fuselage. Zoom extents in all views again. In the SIDE view, position the fuselage so that it lines up (lengthwise) with Dimensions.

	In the TOP view, right-click and Convert to Editable Poly. Click Modify, click open Editable Poly and select Vertex. A bunch of blue dots will appear. Draw a "fence" (when you click and drag a box around a group of objects) around the blue dots at the rear end (top of the viewport) of the fuselage. All the dots (vertices) you selected will turn red. Select Uniform Scale (which is the gmax term for when you shrink/grow everything in the same proportions. When you want to shrink/grow in only one dimension, you can use Non-Uniform Scale.) Now, click and drag either the X or Y arrow and shrink the vertices so that they form almost a single point. Your fuselage should now look like an ice cream cone. The "pointy" end will be the tail of your aircraft.

Set the Pivot Point	Many objects require that you adjust the pivot point. For most objects, their pivot point will be 0,0,0, which is the default. Unfortunately, we will often need to correct the orientations of the three axes in gmax. This is not difficult to do. Wherever you see the phrase "Set the pivot point", just follow these instructions. Do this now for the Fuselage.

	Select Hierarchy Under Reset, click Scale Select Affect Pivot Point Only Rotate the various axes so that, for each of the three coloured arrows: Green points towards the nose Red points towards the right Blue points upwards

Create the Wings	In the LEFT view, create a box using the keyboard with dimensions of 8w, 3l, 0.25h. Name it R_Wing. In the LEFT view, slide the R_Wing so that it is lined up where the right wing should be.

	Select R_Wing and then EDIT-CLONE to make a copy. Rename it L_Wing. Make sure that you've now selected L_Wing, select Modify, and from the drop-down menu choose Mirror. L_Wing should now show up on the other side of the fuselage.

Create the Elevators and Rudder	In the LEFT view, create a box using the keyboard with dimensions of 2w, 1l, 0.1h. Name it R_Elevator. Slide the box left and down until it looks roughly where the right stabilizer should be. As with R_Wing, create a clone, rename it L_Elevator, convert it to poly, and mirror it. Set the pivot point, click Centre to Object, and then slide it forward to the leading edge of the elevator. Normally, we'd also make horizontal stabilizers, but we don't have time.

	Again, make a clone of L_Elevator but rename it as Rudder. In the FRONT view, select the rotation tool and rotate this 90 degrees so it hangs like a rudder (vertically). Slide it over until it is lined up with the centre of the fuselage. In the LEFT view, set the pivot point, click Centre to Object, and then slide it forward so the pivot point is in line with the leading edge of the rudder. Again, we'd normally make a vertical stabilizer, but we don't have time.

Create the Landing Gear	In the LEFT view, create a small cylinder with dimensions of radius 0.5 and height 0.25. Rename it R_Tire_Still. Slide it around using the LEFT and FRONT views until it sits where you think the right wheel should be (approximately at -1.00 meters on the Z-axis). Create a clone and then mirror it so that you now have two wheels. Name the clone L_Tire_Still. Finally, for each wheel, set the pivot point and then also click Centre to Object.

	In the LEFT view, create a small cylinder with dimensions of radius 0.25 and height 0.10. Rename it C_Tire_Still. Slide it around until it sits under the tail where you think the tail wheel should be. Set the pivot point and then click Centre to Object.

	In the TOP view, create a skinny cylinder with dimensions of radius 0.05 and height 0.60. Rename it R_Gear_1. Slide it around until it sits next to R_Tire_Still. Vertically, the top of R_Gear should be a bit inside R_Wing. Create a clone, mirror it, and rename the new object L_Gear_1. For each of R_Gear_1 and L_Gear_1, set the pivot points, then click Centre to Object, and finally slide the pivot points up so that they're in line with the tops of L_Gear / R_Gear.

	At this point, you should have two vertical cylinders - one under each wing. Again, clone R_Gear_1 and rename it as R_Gear_2. Slide this part down by 0.40. Right-click and Convert to Editable Poly. Make sure that Ignore Backfaces is not checked. Fence the blue dots at the top, select Uniform Scale and shrink them by 50%. Do the same for the blue dots at the bottom. Now, repeat this process for L_Gear_2. When you're done, you whould have two sets of telescoping cylinders under each wing.

Create the Propeller	Ordinarily, you'll create five separate propeller objects. For this tutorial, we'll just create one. In the FRONT view, create a cylinder with dimensions of radius 1 and height 0.1. Rename it Prop0_Blurred. Slide it around using the LEFT and FRONT views until it sits in front of the nose, centered with the fuselage. Set the pivot point and then click Centre to Object.

Create the Virtual Cockpit	In the LEFT view, create a box using the keyboard dimensions of 1w, 2l, and 1h. Name it Cockpit_Floor0. Right-click and convert it to poly, then from Modify select "Polygon" and check Ignore Backfacing. In the TOP view, click on the top of the box (which will select the top polygon) and click Delete.

	You should now have a hollow box. The floor and the insides won't be visible if you look at it from above. Switch the view from wireframe to smoothed edges. You see the Fuselage but not the cockpit floor, don't you? That's because gmax polygons are strictly one-sided. Switch back to wireframe. Position the box so that its top edge is lined up with the top of the Fuselage.

	Clone Cockpit_Floor0. Name it Cockpit_Floor_Ext.

	Clone Cockpit_Floor0. Name it Cockpit_Window_Ext. Select "Mirror" and mirror this one across the Z-axis, so it is on top of Cockpit_Floor0 and Cockpit_Floor_Ext.

	Select Cockpit_Floor0. From Elements, select Normal from the drop down menu and then check flip normals.

	At the end of this, you should have three boxes: one on top, two on the bottom. Two facing outward, and one facing inward.

Create the Airspeed Indicator	In the BACK view, create a box with the dimensions of about 0.75h, 0.75w. Name it Instrument_Panel0. Position it near the front of the Cockpit_Floor0 about where a giant speedometer would sit.

	In the BACK view, zoom in and create a rectangle with the dimensions of about 0.1m, 0.06w. Name it Airspeed_Needle0. Position it in the centre of Instrument_Panel0. Set the pivot point and click Centre to Object. Finally, slide the pivot point down to the bottom of the needle and rotate the pivot point so that the blue arrow points forward. In effect, the blue arrow will be the 'pin' around which the needle will rotate.

Texture the Propeller	Switch out of gmax and open up MS Paint. Create a new bitmap and set its dimensions to 128x128. Fill the bitmap with a dark gray colour. Save this file with your gmax files and name it MyUglyAircraft_DkGray_T.BMP. Open up DXTBmp and convert this BMP file to DDS format (the first one on the list).

	In gmax, select Prop0_Blurred. Open the Material Editor. Click New, set Opacity to 10, click the box next to Diffuse, click Bitmap, click Open, and select your light gray BMP file. Finally, click Apply. Close the Material Editor.

	Select Prop0_Blurred (if not already done) and, from the Modify drop-down menu, select UVW Map and click the Fit radio button (near the bottom). Don't worry if things don't look right. They will be correct in CFS3.

	Note: There are generic propeller textures available within CFS3, so when you go to build your first quality model, you'll want to use these instead. See Step 5 later in this guide for more information.

Texture the Cockpit Windows	Switch out of gmax and open up MS Paint. Create a new bitmap and set its dimensions to 128x128. Fill the bitmap with a light gray colour. Save this file with your gmax files and name it MyUglyAircraft_LtGray_T.BMP. Open up DXTBmp and convert this BMP file to DDS format.

	In gmax, select Cockpit_Window_ext. Open the Material Editor. Click New, set Opacity to 20, click the box next to Diffuse, click Bitmap, click Open, and select your light gray BMP file. Finally, click Apply. Close the Material Editor.

	Select Cockpit_Window_ext (if not already done) and, click Modify, and from the drop-down menu, select UVW Map and click the Fit radio button (near the bottom). Don't worry if things don't look right. They will be correct in CFS3.
	It may not be apparent in gmax, but at this point you have created a hazy gray window when viewed from outside the plane.

Add Guns	In the LEFT view, create a Dummy object. You'll find these in the Helpers group of objects. Drag and click to create a small box. If it looks too big, just use the Uniform Scale to make it smaller. Name it Gun_Grp0B0 and place it anywhere along the leading edge of R_Wing.

	Clone Gun_Grp0B0 and name it Gun_Grp1B0. Move it over to the correct position on the L_Wing.

	Set the pivot points for both Gun_Grp0B0 and Gun_Grp1B0.

Animate the Landing Gear	Select R_Gear_2 then click Motion. Set the time slider to 50, click Position, and then create a keyframe at 50. Slide to 75, create another keyframe, and then create another at 100. Use the arrow buttom to go back to the first keyframe at 50. Repeat this process for L_Gear_2.

	Click the big, square Animate button to start recording. Select R_Gear_2 and slide it up by 0.14. Advance to the second keyframe at 75. Click the Animate button again to stop the recording. Again, click Animate again to start recording. Select R_Gear_2 and slide it up by another 0.21. Advance to the third keyframe at 100. Click Animate to stop recording. Repeat this process for L_Gear_2.

	Click the Play button and watch the lower landing gear struts compress upwards again and again. Don't worry that it doesn't go back the other way and don't worry that the wheels aren't moving or that the landing gear doesn't fold underneath the wings. We'll get there.

	From the FRONT view, select R_Gear_1 and rotate it 90 degrees so that it is parallel to the wing and pointing to the fuselage. Do the same for L_Gear_1.

	Select R_Gear_1 then click Motion. Set the time slider to 0, click Rotation, and then create a keyframe at 0. Slide to 50 and create another keyframe. Use the arrow buttom to go back to the first keyframe at 0. Repeat this process for L_Gear_1.

	Click Animate to start recording. Select R_Gear_2 and rotate it back down 90 degrees so that it is pointing down to the ground again. Advance to the second keyframe at 50. Click the Animate button again to stop the recording.

	Click the Play button and watch the upper landing gear struts rotate downward again and again. Don't worry that it doesn't go back the other way and don't worry that the wheels aren't moving.

	If the animation is working, then move the time slider to 50. Select R_Tire_Still, position it in line with the bottom of R_Gear_2, and click Link to Object. From the Object List, select R_Gear_2. To terminate the link function, right-click and select Move. Next, select R_Gear_2, click Link to Object, and from the Object List select R_Gear_1. Repeate this process for the left gear. Now, hit the Play button. You should see the landing gear extending properly during keyframes 0-50 and then compressing slightly during keyframes 51-100.

Animate the Airspeed Needle	This is very similar to the landing gear animation. First, select Airspeed_Needle and then click Motion. Create two rotation keyframes, one at 0 and the other at 1200. (To move beyond 100, you'll need to click the "clock" icon and extend the timeframe to 1200.) Use the arrow keys to move back to the first frame.

	Rotate Airspeed_Needle so that it is pointing to about 10-o'clock. Click Animate to start recording. Advance to the second frame. Rotate the needle to 2-o'clock. Click Animate to end recording. Hit the Play button to watch your needle move.

Add Damage Boxes	In the LEFT view, create a box and stretch it around the Fuselage. Rename it DamageBox_Fuselage. Shrink it or grow it using Non-Uniform Scale so that the damage box more or less holds the fuselage within itself. Check the fit from the TOP view as well, moving and adjusting as necessary. Note: Damage boxes must be rectangular!

	Create similar damage boxes named DamageBox_R_Wing and DamageBox_ L_Wing to fit those parts. Note that the wing damage boxes should be flush with the fuselage damage box. There should be no overlap and there should be no gaps.

Create Endcaps	Clone a copy of R_Wing and name it Endcap0_R_Wing. Change the colour to black. Do the same for L_Wing. Later, in CFS3, if you get a wing shot off, you'll see the black endcap instead. Normally, endcaps are cut much shorter and are shaped to look like twisted metal. These will do for now.

Add Dummy Objects	In the LEFT view, create a Dummy object. Scale it down until it's fairly small. Name it Pilot0 and position it near the back of Cockpit_Floor0. The top of the box should be just beneath the floor and inside the Fuselage. Set the pivot point.

	In the LEFT view, create a Dummy object. Name it MyUglyAircraft. Place it at the centre of gravity at 0,0,0. Set the pivot point.

	Clone a copy of MyUglyAircraft and name it Cockpits. Set the pivot point, although it should inherit the correct pivot point from MyUglyAircraft. Leave it where it was created. Don't worry that it's sitting on top of MyUglyAircraft.

	Clone a copy of MyUglyAircraft and name it Cockpit_Virtual0. Set the pivot point, although it should inherit the correct pivot point from MyUglyAircraft. Leave it where it sits.

	Clone a copy of Pilot0 and name it Eyepoint0. Place it inside the cockpit where you think the pilot's head should be. Set the pivot point.

Link all Objects	Using the Link to Object button, link these objects together. After you create each link, right-click and select Move to exit the link function before creating the next link.

Select this object . . .

. . . and link it to this object

Airspeed_Needle0

Instrument_Panel0

Instrument_Panel0

Cockpit_Floor0

Pilot0

Cockpit_Floor_Ext

Eyepoint0, Cockpit_Floor0

Cockpit_Virtual0

Cockpit_Virtual0

Cockpits

Gun_Grp0B0, R_Gear_1

R_Wing

Gun_Grp1B0, L_Gear_1

L_Wing

DamageBox_R_Wing
DamageBox_L_Wing

DamageBox_Fuselage

R_Wing, L_Wing
R_Elevator, L_Elevator, Rudder
Cockpit_Floor_Ext, Cockpit_Window_Ext, C_Tire_Still

Fuselage

Fuselage, Cockpits, DamageBox_Fuselage

MyUglyAircraft

	At the end of all this linking, MyUglyAircraft should be at the top of your hierarchy. Don't forget to right-click and select Move to exit the link function after you have created each link.

Export to CFS3	For each object in the Object List - each one, one at a time - select it, click Hierarchy, and click Scale under the Reset section. This will remove any scaling; scaling always gums up exports.

	In the TOP view, select MyUglyAircraft and rotate it by 180 degrees so that the nose is facing the other direction (i.e. pointing straight up). Note that because MyUglyAircraft is the highest object in your hierarchy, all of the other parts rotate along with it.

	Select File - Export and, find the aircraft\3gb_hurricane_mkia\model directory in CFS3 and save over top of the 3gb_hurricane_mkia.m3d file. Note that this will create new m3d files for both the airplane and the virtual cockpit.

	Copy the DDS files (that you converted from BMPs earlier on) to the texture subfolder of aircraft\3gb_hurricane_mkia folder in CFS3. Unlike the export process you just followed for the M3D file, you will not save your DDS files over top of any existing files. Just leave them named as they are and copy them in.

Takeoff	Start CFS3, choose the 3gb_hurricane_Mk1a and go fly your airplane. Note: if you see a smiley face instead of an airplane, it means that you somehow deleted the original m3d file and didn't name your model correctly. If you see the Hurricane, it means you didn't save over top of the right m3d file.

	While you're flying, check out the following:
	Try the virtual cockpit. (Cycle through F4 and then toggle F3) Is the airspeed needle working correctly? Can you see the inside floor of the cockpit? From the outside, can you see the pilot sitting inside the cockpit? Do the windows look nice and hazy? At first, you won't see a propeller. However, once the engine got going, did you see a translucent prop disk? Can you see the elevators and rudder working? Are they pivoting on the correct pivot points? Press "G". Can you see the landing gear retract and extend? Are the guns working? You should see tracers and muzzle flashes. If everything is working, try a quick dogfight.

You're finished! And with thirty seconds to spare! Okay, maybe this took you longer than 60 minutes. And yes, you're flying an ugly brick that is just programmed to behave like a Hurricane Mk I. However, you did get it up and flying didn't you? Besides, you now understand all of the key building blocks. From here on in, most of everything else you do will be fine-tuning. I will mention this point again: it is very bad form to borrow and redistribute an existing flight model without first seeking the author's permission. In this case, we used Bill "SPITFRND" Wilson's Hurricane Mk I flight model, but we will not redistribute this as our own work. Later in this guide, you will learn how to build your own flight model. Thus, you will have no need to plagiarize someone else's work.

Building Your First "Real" Aircraft
Now that we've covered off the basics, you can start working on a high-quality model. For this one, your objective will be to get it to look right and to fly right. It will probably take some time, but the results (and even the journey itself) will be worth it.

For the most part, tutorials have already been written that address the fundamental aspects of gmax aircraft modeling. For my part, I will try and point you to some helpful tutorials while also adding my own "30,000-foot" comments.

Step 1: Aircraft Selection You probably have a few aircraft in mind that you'd like to build. That's good. Don't lose track of them. But I should caution you, dear reader, that building an aircraft will require an enormous investment of your time, so do pick an aircraft that you're passionate about. I'd also like to suggest that you consider your choice(s) in light of the following criteria:

Historical Significance	Do some research so that you understand the role this aircraft played. Where was it used? By which nations? In which theatres? For what types of missions? Against which enemy aircraft? Which exact versions were used and in what quantity?

Choose a Specific Model	Having researched the background, you should pick a specific version. When building my Potez Po-63, I found that there were reconaissance (Po-63.11.A3, Po-637.A3), heavy fighter (Po-631C.3), and bomber (Po-633) versions. Once I had settled on the Po-63.11.A3, it was easy for me to determine which data were relevant to my model.

Contribution to the CFS3 Community	Has someone already built this exact aircraft for CFS3? Different versions are eagerly received, but how many copies do we need of the Hurricane Mk IA? One good one should be enough. Repaints are a different story altogether. If your model exists but you need it in desert camouflage, then you might just want to issue a "skin" for that model. Contact the original designer - they'll probably be glad to help.

Availability of Data	This may be the most frustrating task of all. Some planes have gobs of available data. Others have very little. For best results, you'll need lots of data - as well as a reasonable basis for making educated guesses to fill in the gaps.

Must Have Data	As a general guideline for beginners, I would not recommend attempting an aircraft for which I could not locate the following information:
	Top speed at specified altitude Climb rate Empty and fully loaded weight Basic dimensions Engine specifics (Can often be found at http://www.avhistory.org/) Armament and payload specifics

	This information is often available on the Internet. Just punch in the name of your aircraft and you're certain to come up with dozens of sites.

	Also, you'll need to obtain a good three-dimensional view of the aircraft. These can be found at several sites. For a list, refer to:
	http://www.freeflightdesign.com/resources.html

	Weapons and engine information can often be found at http://www.avhistory.org/. Look in the Knowledge Base to find the pages labeled "Weapons Standards" and "Engine Standards".

Nice to Have Data	For best results, look for the following:
	A scale model kit in 1/48^th scale. Kits are available for just about every airplane imaginable. You might even find a review of a model kit on the Internet, including close-up pictures showing cockpit detail. Cutaway diagrams showing the exact locations of fuel tanks and other components. Photos of the cockpit and other components. Rare warbirds can be found in museums around the world. Maybe they'll let you snap a few pics? Original flight manual. A really good book on the aircraft. First-hand accounts by pilots.

Step 2: Diagram Preparation
As part of your data collection, you will have located the best three-dimensional diagram that you could find. When you start working in gmax, each of the viewports (top, front, left, or whatever) can hold one of these diagrams. As you build, you will use these diagrams as templates to "trace" the image of the aircraft.

However, before you load them to gmax, you should prepare the diagrams (which I'll assume you've converted to bitmaps). To make things easier for gmax to handle, you should use 1024x1024 bitmaps, which are easily created using MS Paint.

Regardless of how you build your aircraft, gmax will assume that the centre of gravity is at 0,0,0. Yes, you can adjust this later. However, it might be easier to arrange your bitmaps so that - when they appear in gmax - the airplane's centre of gravity will inherently line up at 0,0,0. To configure your bitmaps in this manner, follow these steps:

Start with a single image that includes top, side, and front views. This will ensure that all three views are scaled identically.
Shrink or grow the image so that the fuselage is about 600 pixels long.
Using a 2-pixel wide red stripe of about 10 pixels in length, mark each of the centers of gravity. Each view will need two CoGs marked as follows:

For the overhead view:

The lateral (side-to-side) centre of gravity should cut the fuselage cleanly in half.
The longitudinal (nose-to-tail) centre of gravity should fall 25% along the MAC (mean air chord). The MAC is the length of the wing from leading edge to lagging edge, measured near the wing root. In other words, the CoG should fall about one-quarter of the way back from the leading edge of the wing. Often, this will line up with the landing gear, when fully extended. Ignore extended wing fairings when locating the main chord.

For the side view:

The longitudinal (nose-to-tail) centre of gravity should fall 25% along the MAC (mean air chord). The MAC is the length of the wing, from leading edge to lagging edge, measured near the wing root. Ignore any extended fairings.
The vertical (top-to-bottom) centre of gravity is often aligned with the middle of the prop spinner.

For the front view:

The lateral (side-to-side) centre of gravity will be the same as in the side view.
The vertical (top-to-bottom) centre of gravity will be the same as in the side view.
Bear in mind that some diagrams are not scaled identically. Compare the length/width/height in each diagram and adjust as needed.

Having marked the CoGs, you can now copy-and-paste each view into a separate bitmap.

Overhead View Bitmap: Create a new 1024x1024 bitmap. Copy and paste the overhead view here. If necessary, rotate the image so that the nose is pointing to the bottom. Then, carefully move the image around until both the vertical CoG stripe falls on the 511th and 512th vertical pixels and the horizontal CoG stripe falls on the 511th and 512th horizontal pixels. In other words, if the vertical and horizontal CoG strips were extended from top to bottom and from left to right, they should divide the image into four equally-sized quadrants. Be patient. This can take quite a bit of nudging. Save the bitmap as aircraft_Top.bmp.

To make things easier, I often paint green stripes along the 511th and 512th pixel-rows and pixel-columns of a blank 1024x1024 bitmap. However, I paint the CoG stripes in green. Then, it's just a matter of nudging the image around until the red stripes overlap the green stripes. Note that the image of the aircraft will not sit in the middle of the bitmap. You should have quite a bit of "white space" in front of the nose if you've placed it correctly.

Side View (Left) Bitmap: Create another new 1024x1024 bitmap. Copy and paste the side view here. If necessary, flip the image so that the nose is pointing to the right. As with the overhead image, carefully move the image until the vertical and horizontal CoG strips fall of the respective 511th and 512th pixels. Save the bitmap as aircraft_Left.bmp.

Front View Bitmap: Create another new 1024x1024 bitmap. Copy and paste the front view here. As with the overhead image, carefully move the image until the vertical and horizontal CoG strips fall of the respective 511th and 512th pixels. Save the bitmap as aircraft_Front.bmp.

Now that you've created the images, you can open gmax, and load the bitmaps into the backgrounds of the respective TOP, LEFT, and FRONT viewports. Next, you'll want you'll want to create a dimensions box, as we did in the tutorial. This box should be precisely as long and as wide as is your actual aircraft. Get the dimensions from one of your reference sources. If you aren't sure about the height, just use 3.0 meters, and you can adjust it later. Also, don't worry if your dimensions box looks too big or too small. We'll adjust that in a moment.

Next, you'll need to Zoom Extents in All, and then separately zoom each viewport until the nose, the tail, and the wingtips all touch the boundaries of the dimensions box. Start with the TOP view and get the wingtips to fit. Then Lock View and do the same in the FRONT view. After you make adjustments and Lock View, Zoom Extents in All to see where the image wants to rest. Keep adjusting until everything lines up.

Once the wingtips are correct, do the same for the fuselage length. Chances are that you'll actually have to slide the dimensions box along the Y-axis. That's fine. Just make sure that the fuselage fits in both the TOP and LEFT views. Lastly, you can adjust the height using the TOP and SIDE views. Move the dimensions box so that the box encompasses everything from the top of the vertical stabilizer to the bottom of the wheels.

When you're happy with everything, save the project as aircraft_v001_Bitmap. Save it again as aircraft_v002_Fuselage and then you can start working on the fuselage. Incrementing your files in this manner will make it much easier to go back a few steps when you mess up something later on.

For some more tips on bitmap placement, see Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax" at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.

Step 3: Basic Shaping
I'm a 30,000-foot guy, so I like to break things down into opposing paradigms. In this case, I'd like to propose that most gmax modelers follow one of two approaches.

Approach #1: Combined Object Approach
Essentially, this is what we did during the crash course. We built a bunch of pieces, separately, and then we stuck them together. The advantage is that it was fast and easy. The downside is that it yields substandard aesthetic results.

Two problems become apparent. First of all, when the wings and fuselage are built separately, the joint between them is rather abrupt. However, if you look at a real wing, you'll see a smooth transition from the fuselage out to the wing. One solution to this problem is simply to add another panel of polygons and use it to smooth out the area.

The second problem is that our textures will start to get messy. My first modeling attempt (which I later re-did) was a Morane-Saulnier MS-406. The wing ran through the fuselage, as opposed to running underneath as it does in most airplanes. No problem, I thought. I'll just paint the underside of both the wings and the fuselage the same colour - everything will look great. However, when I viewed the model after texturing, the textures appeared distorted where the polygons for the two objects intersected. That's because overlapping polygons are a big no-no in gmax modeling. In fact, the SDK even includes an admonishment to this effect.

Would anybody really notice these shortcuts? Perhaps not. It's a tough choice. Quite simply, if you don't want to spend a lot of time in gmax, then consider using this approach. However, if you're trying to build a masterpiece, then you will have a hard time achieving your goal with this approach. There are cases where this approach is highly recommended, though, such as when constructing a lower LOD (level of detail) where the model will only be seen at a distance.

If you're starting out, or if you prefer the Combined Object Approach, then I recommend Darren Brooker's "gmax aircraft tutorial", in which he assembles an elegant FW-190. http://www.aerodynamika.com/gmaxtut/gmax000.htm.

Approach #2: Extruded Object Approach
If assembling a model from different objects doesn't work so well, why not just build everything from a single object? With this approach, you will start with a single object (probably the fuselage) and then extrude the polygons as you need. Once you're happy with your results, you simply detach the wings (and other objects) from the fuselage as needed.

Extruding is where you select a group of polygons and then pull them outwards (or push them inwards). Imagine that your model is like a giant filing cabinet and that each polygon is a drawer. When you extrude, it's as if your pulling out (or pushing in) one or more of those drawers.

The advantage with this approach is that you get wonderfully smooth transitions between the wing, the fuselage, and virtually every other part. For example, the fuselage can slope down gracefully into the wing. The trick is to know where to add slices so that you can achieve the shape you want.

With my Potez Po-63.11A.3, I used extruding to build the wings, stabilizers, elevators, tail, and twin rudders from the fuselage. Furthermore, with several strategically placed slices, I was able to extrude the engine nacelles from the wing. This took quite some time (and more than a few attempts - save your work often), but I was able to achieve a much smoother look. To top it off, I built the engine cowlings from separate objects, which made them look as if they were bolted on top of the nacelles (which, of course, is how airplanes were made).

The downside to this approach is planning. You have to plan your slices very carefully. For example, if you add slices after you've separated your objects (which you likely will have to do at some point), you may create a small but annoying "stretch" in the seam. Yes, you can probably fix this by stretching it back, but it's still a nuisance. By the same token, if you're slicing your wing and you forget to detach it first, you may end up adding unwanted slices to your horizontal stabilizers.

If you prefer the Extruded Object Approach, then I recommend Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax", in which he creates a meticulous Me-334, at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.

Perhaps it's my Scottish heritage, but I try to be as stingy as I can when it comes to polygons. For me, it just isn't worthwhile to load up a model with so many polygons that it only flies at 10 frames per second. Besides, if I want to capture micro-details (like a minor bump in the fuselage), I think it's more efficient to handle them through texturing (i.e. just paint the detail onto your bitmap).

Others could argue, quite correctly, that personal computers are getting more and more powerful every year, so why shouldn't we crank up the detail? (I'm only running on a Celeron 600, remember?) They could also argue that greater detail allows the player to become more immersed in the experience. Small touches, particularly those within the virtual cockpit, can make a difference - when taken collectively.

Having done my best to represent both sides of this argument, the following steps will reduce the total number of polygons in your model and, thus, make it more efficient:

If two or more vertices share the same location, then collapse them together.
You may find cases where a layer of vertices is "sandwiched" between two other layers. This will often happen when you extrude a wing using two rows of polygons. If possible, either delete them or slide them up/down and collapse them with nearby vertices.
Go easy on the slices. Every polygon you cut in half creates two polygons. If you only need a few new vertices, consider using cuts or divides instead of slices.
Spend your polygons where they'll be noticed. The front part of the fuselage is often a good place to invest.
Don't go hog wild. For your aircraft to perform at lower levels of detail (discussed later), you'll need to keep the polygon count low.

Step 4: Control Surfaces
You'll need to "cut" the control surfaces (i.e. elevators, rudder, flaps, and ailerons) from your existing objects. You will create these new objects by selecting the polygons you want, detaching them and then renaming the new object. Adding new edges may be required, and since this can take a few attempts I recommend that you save regularly.

In order for the animations to work, you must name the parts correctly. After that, you'll need to set the pivot points so that the object will rotate correctly. Just follow the instructions in the tutorial and you'll be fine. Herewith, a few more notes:

Parts	Valid Names
Ailerons	R_Aileron, L_Aileron, R_Aileron_1
Flaps	R_Flap, L_Flap, R_Flap_1, etc.
Elevators	R_Elevator, L_Elevator
Rudder	Rudder, Rudder_1, etc.

As you can see, if you need to create split flaps or split rudders (like on a P-38), just add a 1 or 2 to the part name. For example, a P-38 might have Rudder and Rudder_1.

One more note on flaps: they're often visible only from below, as opposed to ailerons and elevators that are visible from both top and bottom. Therefore, you'll probably just detach the "flap" polygon from the underside of the wing. However, if that's all you do then, then when you deploy your flaps, they'll be invisible from behind! That's because polygons are one-sided. To correct this, you'll need to:

Create a copy of the "flap" polygon and re-attach it to the wing. This will keep the underside of the wing from becoming invisible when the flaps are deployed.
Create a copy of the "flap", flip the normals, and attach it to your original "flap". This will keep the flap from becoming invisible from behind.
Nudge the flap down by 5mm (0.005). This will minimize flickering in CFS3 due to conflicts between the polygons of the flap and the lower surface of the wing.

Once you've detached the parts, you'll want to add a small cylinder along the joining edge of the control surface. This should be sized and rotated so that it fits perfectly with the object. Use the cylinder to set the pivot point BEFORE you join it with the object. When you join the cylinder with its control surface, select the cylinder first, then select Attach, and then select the control surface. Otherwise, your resulting object will inherit the wrong pivot point.

For some more tips on control surfaces, see Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax" at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.

Step 5: Details
By this point, you've created most of the major components of your aircraft. So, perhaps now would be a good time to add some of the finer details like propellers, landing gear, canopy frames, and so forth.

Propellers: Propellers are easy to make - once you know how many you need. As it turns out, each engine will require four different propeller-blade objects. In addition, each set of propellers will link to a common object, bringing us up to five separate pieces per engine. Here they are:

Prop0	This is the spinner. It’s the bulbous cone to which the actual propeller blades are attached. Usually, it sits dead centre to the engine and it will control the rotational movement of all four propellers. To create a spinner, create a cone and then malform it as needed. Set the pivot point and you're done. I also recommend that you jot down the exact coordinates of the pivot point. Later on, you can simply enter these coordinates when you have to line up your other propellers. If your aircraft has a cannon firing through the spinner, just insert a small cylinder and align it with the same pivot point coordinates.

Prop0_still	This prop consists of the actual blades. It will be used when the engine is stopped or when it is turning very slowly. Typically, you will create one blade, align its pivot point to the spinner, and then use the ARRAY function to create additional copies distributed evenly about the Spinner. Finally, select all three blades and then link them to the Spinner. For a good tutorial on still propellers see Darren Brooker's "gmax aircraft tutorial" at http://www.aerodynamika.com/gmaxtut/gmax000.htm.

Prop0_slow	This prop consists of three triangles. It will be used when the engine is turning relatively slowly (which is not often). Create it exactly as you would prop0_still except use triangles instead of blades (you don't need to add the twists and tapers). Alternatively, you can create a cone, flatten it out, and then cut out the sections you don't need. Centre the object on the Spinner's rotational axis and link it to the spinner.

Prop0_blurred	This prop consists of a plain old disk. It will be used when the engine is turning relatively quickly (which is ften). Create a cylinder, flatten it out a bit, centre it on the spinner, and then link it to the spinner. Bearing in mind that blurred props look pretty much the same, you can save yourself some time by simply borrowing one of the blurred props from the gmax sample models. The Ju-88 has a 3-bladed prop while the P-47 has a 4-bladed prop. To borrow a part from another gmax file, use the Merge function.

Prop0_bent	Not often used, but it comes into play during crashes. This is identical to prop0_still except that the blades are all twisted and bent backwards, as they would be after a propeller strike. Make a copy of prop0_still, rename it, and then twist it to your heart's content.

Prop Textures	Still and bent props are textured in the same manner as other parts. However, slow and blurred props have generic textures available. You'll find these in the "Shared" sub-folder of your "Aircraft" folder. There are separate textures for German (prop_german.dds) and British/US (prop_us_brit.dds).

Landing Gear: Here's an area where you can add a lot of detail or just a little. The key to success is to name and then link all of your parts correctly.

C_Gear_1, R_Gear_1 and L_Gear_1	The upper landing gear struts. Generally, these parts will rotate downwards between keyframe 0 and keyframe 50. Often, the coverings will link to these.
C_Gear_2, R_Gear_2 and L_Gear_2	The lower landing gear struts. Generally, these parts will compress upwards into the uppoer struts between keyframe 50 and keyframe 100. Often, the wheels will link to these. C_Gear_2 isn't often required as the primary C_Gear object can be animated to handle both extension and compression.
R_Gear_7, L_Gear_7, etc.	Extra parts that must be animated independently of R_Gear and L_Gear. Often, landing gear doors will be animated separately.

Gear_Mudflap, etc.	Extra parts (like mudflaps and fenders) that will simply follow the path of the part to which they are linked, just as the tires do. These parts can be named however you like.

R_Tire_Still	The tire that will be shown when it is stopped or rotating slowly. The texture should show lug nuts and other minor details. Also create C_Tire_Still and L_Tire_Still.

R_Tire_Blurred	The tire that will be shown when it is rotating rapidly. The texture should show a fairly blurred wheel. Also create C_Tire_Blurred and L_Tire_Blurred.

In completing our discussion of landing gear, I should emphasize the importance of correctly configuring your landing gear. In particular, the left, right, and center gear must all compress properly. Later, when we configure the contact points, we will use the compression that you have built into your model. If you don't build it properly now, then you'll run into problems later on. In particular, takeoffs from unpaved airfields require more static compression.

Note that landing gear parts can also be used to animate other objects that often move at the same time as landing gear extends and retracts. A good example might be a ventral antennae. If you do animate any parts in this way, make sure that you use either R_Gear or L_Gear. NEVER NEVER NEVER use C_Gear to animate any parts other than your center landing gear. Otherwise, there is a good chance that CFS3 will not display your model correctly while in 'facilities' mode.

As rules of thumb, I recommend the following compression:

Object	Keyframe 50	Keyframe 75	Keyframe 100
L/R Gear	Fully extended	Compress 0.14m	Compress 0.21m (Total 0.35m)
C Gear	Fully extended	Compress 0.12m	Compress 0.06m (Totao 0.18m)

Canopy Frames
These are easy enough to create, but they take quite a bit of time. For the most part, you will try to arrange your edges so that they line up with the frames, and then you will "chamfer' them - which will turn the edge into a skinny polygon. Expect to do quite a bit of fiddling. I would even go as far as to re-align every single vertex one at a time, collapsing duplicates as needed.

When everything looks right, detach the entire canopy frame from the fuselage so that it becomes a separate object. If you want to create a sliding portion of the canopy, you can then detach the appropriate pieces from the canopy frame.

For more help with canopies, see Darren Brooker's "gmax aircraft tutorial" at http://www.aerodynamika.com/gmaxtut/gmax000.htm.

Pilots and Other Pieces
We added a pilot object to our model in the tutorial. However, you can certainly build your own figure if you don't like how the default model looks. You should also add gunsights, pitot tubes, antennae, and anything else that would enhance the realism of your aircraft.

If you prefer, you can create your own pilot or crew models and use them instead of the stock object. The catch is that custom objects will not bail out correctly, should you ever have to hit the silk.

Step 6: Cockpits
No other subject caused me more anxiety than that of cockpits, notwithstanding assurances from the CFS3 forums that building them was a snap. Well, they are pretty easy to build - once you understand the basics.

The Virtual Cockpit Node
As we saw in the tutorial, it's relatively easy to create a virtual cockpit. Just create a dummy object called cockpit_virtual0 (the VC node) and link it appropriately. From there on, simply link objects to the VC node as needed.

If you want more virtual cockpits (i.e. for co-pilots, bombardiers, or gunners), just add more cockpit_virtual# dummy objects and number them sequentially. There is a limit to the number of VCs, so keep it reasonable.

Eyepoints
The critical ingredient of any virtual cockpit is a dummy object called eyepoint0. (Note that the "0" does not have to correspond to the VC number. A VC can have more than one eyepoint.) The position and orientation of the eyepoint controls what can be seen from that position. Link eyepoint# to the VC node.

Objects in the Virtual Cockpit(s)
For the most part, if you want something to be seen inside the VC, you'll need to link that part to cockpit_virtual0 (or whichever VC it is). This may not apply to the wings and other external parts (which are usually shared with LOD_100), but it will certainly apply to the instrument panel, cockpit interior (see below), seat, canopy frames, gauges, and so forth.

To see the canopy frame from inside the VC, simply clone it and then flip the normals. If part of the nose is transparent, then clone a few polygons. In both cases, you'll need to link these objects to the virtual cockpit.

For any object in the VC, I recommend that you append the name with the VC number. For example, the copy of the pilot's seat that will live in the VC should be called seat0. This will simplify the linking process later on when you're trying to remember which part belongs where.

Beyond that, you're free to add whatever else you like. For a good example, refer to the P-47D-25 sample that is included with gmax. Note which parts are included in the virtual cockpit and which are included in the regular cockpit.

The "Regular" Cockpit Node
Some of the objects in your virtual cockpit should be visible from outside the aircraft. These would include the pilot, the seat, the interior walls, and perhaps the instrument panel (just the bitmap image - not the needles and gauges). To accomplish this, create a dummy object call cockpit and link it to the fuselage. (Unlike virtual cockpits, you don't actually need to create a cockpit node. However, you may find it easier to organize your parts by creating a cockpit node in this manner.) Then, link all of the objects in your regular cockpit to cockpit

For the most part, the objects in your "regular" cockpit will be clones of those in your virtual cockpit. Again, for the sake of clarity, add the virtual cockpit number to any object that links to a virtual cockpit, but leave the number off for those that belong to the "regular" cockpit. For example, instrument_panel should link to cockpit, but instrument_panel0 should link to cockpit_virtual0.

The Cockpit Interior Walls and Floor
Essentially, you'll create a small "bathtub" that will fit inside your fuselage. The easiest way is to create a box, delete the top polygon, and then flip the normals so that the box can be seen from the inside only. The top, forward, and rear edges of the box should be matched perfectly with your fuselage. Divide the top edges as needed to add more vertices.

You'll need two copies of this bathtub - one to be linked to the virtual cockpit and one to be linked to the "regular" cockpit. Note that in the tutorial, we created three copies, but that's because our cockpit didn't fit perfectly into the fuselage. However, when building "for real", the fuselage (which usually includes the canopy frame), is responsible for the external view.

The Dreaded Instrument Panel
Before you create any gauges, first create an object that will fit neatly inside the cockpit. This object should include a flat surface large enough to hold - you guessed it - the instrument panel. Make sure all of the edges line up perfectly with either the fuselage or the cockpit interior walls.

The instrument panel should be textured like the background surface of the actual instrument panel. Usually, this will be something dark with a semi-glossy metallic feel to it.

The Dreaded Gauges
There are several types of gauges and indicators that can be included. For details, see the gmax documents that came with the SDK. For the most part, gauges are simply "tooltips" that provide popup information in CFS3 when the mouse is positioned overhead.

Visually, the gauge will usually be a perfectly square polygon to which the image of an instrument face is applied. With the stock gauges, the images tend to be circular with little bolts in the corners to make it look like the gauge was bolted onto the instrument panel. You'll need to convert the stock gauge files to BMPs in order to see them but you can do that easily enough with DxtBMP. With some exceptions, the stock gauge files each hold 16 gauges each, arranged in a 4x4 pattern.

To create a gauge, first create a box that is perfectly square from the front and perhaps 5-10mm thick. The back of the box should be butted up against the instrument panel. See Step 14 below about creating a material using the Material Navigator and then applying that material to an object. Position the image so that it is centered.

Creating separate objects for each gauge can be a bit tedious. However, it will pay major dividends later on if you need to rearrange your gauges. With this approach, you simply move the gauges around as needed. In fact, if you link the needles to each gauge, then the needles will reposition themselves automatically.

The Dreaded Instruments
The indicators (e.g. needles) are responsible for registering actual information. Assuming you've already textured your instrument panel, you should be able to see exactly where each indicator should be placed.

Needles are created using simple polygons. Create them in the BACK viewport and then switch to the LEFT viewport to place each needle about 5mm above its gauge. You may also find it helpful to create three basic sizes of needles (large, medium, small), set their pivot points (remember that the blue arrow should point forward), and then clone them as needed. This will insure that your needles look consistent.

You'll notice that many of the DDS files used for gauges and needles have large portions of black. In many cases, black has been assigned as the alpha channel, meaning that any objects textured with this colour (by that DDS) will appear transparent. This allows you to use a rectangule for your needle and still end up with some slender-looking gadget.

Link each needle to its gauge. This will make it easier to move your gauges later, if necessary.

Some instruments are a bit different from needles. These include the following:

Compass: This is either a disk or a cylinder which rotates as needed. I've had success in creating a readable compass by creating a 36-sided cylinder. Use the cylinder mapping within the UVWMap modifier to place the image onto the outsides of the cylinder. You may need to switch viewports before it works.

Artificial Horizon: This is a combination of a dummy object and a cylinder. The dummy object captures the rolling or banking motion, while the cylinder captures the vertical or pitching motion. One of the German stock gauge files uses a plain black artificial horizon with two white lines. This one is very easy to map to any object. Just scale the image to fit your cylinder using the UVWMap modifier.

Switches: These include toggle switches but also include landing gear indicators (lights that turn red or green to indicate gear position). These are usually polygons which move in andn out of place as needed.

Levers: These include rudder pedals, joysticks, and throttle levels. Simply create a realistic looking object and then set it to rotate or move as needed.

Canopy: This is simply a copy of your sliding canopy.

Step 7: Armament If you haven't already added some skinny, machine-gun shaped objects where they should be, then please do so. Once you've done that, you'll need to add some dummy objects to indicate where the muzzle flashes should originate and in which direction the bullets should fly. Fixed Guns Guns, including both machine guns and cannons, are mounted by creating a dummy object and orienting it so that it fires in the proper direction. Guns are labeled as follows: gun_grp#b# (e.g. gun_grp0b0) Groups (grp) refer to the number of guns identified in the XDP file, where "grp0" is the first group. The next group is "grp1", and so on. Barrels allow you to create multiple flashes from a single group of guns by simply adding more barrels. Flexible-Mount Guns Typically, these are defensive guns mounted either at the rear of the cockpit or in a turret. These are created in much the same manner as fixed guns, except that they require two additional dummy nodes. From a hierarchy perspective, you will need the following:

gun0_l_r	Dummy node with axes positioned such that (a) green axis points in line with barrel and is lined up so that it is 'shooting' at the gunner and (b) blue axis points up. Links to the aircraft fuselage or the cockpit. The gun will rotate wherever you place this object, so place this node at the base of the gun mount. The dummy object needn't be very large, so feel free to shrink it down to size.

gun0_fore_aft	Dummy node with axes positioned such that (a) green axis points in line with barrel and is lined up so that it is 'shooting' at the gunner and (b) red axis points up. Links to gun0_l_r. As with the previous node, place this node at the base of the gun mount. You may find it easier simply to clone gun0_l_r and rename it as gun0_fore_aft.

gun_grp0b0	Same as in fixed guns. Links to gun0_fore_aft. Place this at the end of the gun barrel.

As a general rule, all GUN_GRP#B# nodes should be attached to the LOD_100 level. Otherwise, CFS3 won't always recognize the guns. You may also include additional copies in other LODs or in the virtual cockpit. Just make copies and include a numerical extension (i.e. GUN_GRP1B0_50 or GUN_GRP1B0_1 for LOD_50 or the Virtual Cockpit 1). If you didn't already create a beautiful model of a machine gun, then you should at least include a long cylinder to represent the gun barrel. The barrel and all other machine gun parts should be linked to gun0_fore_aft. If you like, you can also configure the gunner's eyepoint to swivel in line with the barrel of the gun. To do so, simply link the eyepoint# to GUN#_FORE_AFT. For added realism, position the eyepoint towards the back of the gun so the player can look along the entire length of the barrel.

Hardpoints Once again, these are dummy objects that will indicate the points where payloads (i.e. drop tanks, bombs, pontoon-mounted machine guns) will be carried. Hardpoints should be named pylon#, where pylon0 is mounted along the centerline, odd numbered pylons are situated to the left and even numbered pylons to the right.

Step 8: Keyframe Animation Most parts are controlled by CFS3 automatically, provided that they are named correctly. However, landing gear and some other parts require keyframe animation. As we saw in the tutorial, keyframe animation consists of defining two points in time (frames) and then setting the position of the object for each frame. Gmax will then work out all of the intervening motion. For more help with keyframe animation, see the gmax landing gear tutorials at http://www.aerodynamika.com/gmaxtut/gmax000.htm. Instrument Animation Before animating any instruments, make sure that the pivot point is set so that the z-axis (blue arrow) points through the needle. The z-axis will be the "pin" on which the needle rotates. The x-axis (red arrow) should still point to the right of the aircraft. Some instruments don't require keyframe animation and these are listed in the SDK documentation. They include pure rotational instruments such as altimeters (where 25% always points to 90-degrees, 50% to 180-degrees, and so forth). Most other instruments require only rudimentary keyframe animation. However, some gauges won't progress in a uniform manner. For these cases, such as the vertical speed indicator, you'll need to calbrate the gauges using several different keyframes as reference points. To get your needle to act correctly, you'll need to create a series of keyframe animations for several combinations of airspeed and needle position. When doing so, bear in mind that the keyframe relates to speed in kilometers per hour, so you'll need to convert if you want to register speed in miles per hour. First, work out your major increment-positions combinations. (1 kilometer = .6313 miles or 100 MPH = 158.4 frames.) Here's an example:

Rotation Frame	Speed (MPH)	Needle Angle
0	0	0 degrees
79	50	45 degrees
158	100	95 degrees
317	200	190 degrees
475	300	290 degrees

Ready to create the keyframes? Here we go:
Start with the needle pointing to zero. Create a rotation keyframe at zero (keyframe 0). Create another rotation keyframe at 79 (keyframe 79). Rewind to keyframe 0. Click Animate to begin recording. Advance to keyframe 79. Rotate the needle to the 50 MPH increment. Click Animate to end recording. Create a rotation keyframe at 158. Rewind to keyframe 79. Click Animate to begin recording. Advance to keyframe 158. Rotate the needle to the 100 MPH increment. Click Animate to end recording. Repeat steps 7 through 10 until you're done.
One word of caution: if you make a mistake, delete the errant keyframes and start over from your last good keyframe. Don't try to "wind back' a needle if you record it in the wrong position or you'll end up with a 300-degree rotation.

Step 9: Damage Boxes
CFS3 uses damage boxes to determine where to assign damage for incoming hits. Therefore, you must create a set of ordinary boxes to contain the various sections of your aircraft. As with the endcaps, each damage box should be named according to its part. Thus, the damage box for R_Wing should be called Damagebox_R_Wing.

A few notes worth mentioning, most of which I culled from a Netwings forum post:

Consult the XDP file of any AvHistory aircraft for a list of typical damage boxes.
Damage boxes must be rectangular, otherwise they will not work properly. However, you may rotate them, which can be helpful when trying to match wing dihedrals and such.
To manage peculiar shapes, split things up into multiple damage boxes such as Damagebox_R_Wing_1 and Damagebox_R_Wing_2. CFS3 would consider both of these to be part of one damage box called Damagebox_R_Wing.
Wingtip damage boxes should be about half as thick as the corresponding wing damage boxes.
What you see in gmax isn't always what you get in CFS3. Start CFS3 with the -m3dview switch at the end of the shortcut. This will open up the model viewer which allows you to see where CFS3 thinks the damage boxes are placed.
Consider placing special damage boxes for turrets, engines, and pilots, since these are logical target areas.
Make notes regarding the names of your damage boxes. You'll need them to construct the XDP file later on.

Step 10: Endcaps
Once you're happy with the shapes of your basic objects, its time to create some endcaps. These will appear only when the part for which they have been named (e.g. r_wing) has been blown off. You'll need one endcap for every damage box you plan to have. See the SDK documents for a list of endcap names.

To create the endcap, make a copy of the (to be) destroyed object and rename it. Then, slice it down to size and extrude it so that it looks all twisted and gnarly. When it comes time to texture, remember to paint the tip so that it's all black and burnt.

When it comes to linking, endcaps should be linked to the same part as the object is linked. For example, R_Wingtip and Endcap0_R_Wingtip should both be linked to R_Wing.

Step 11: Emitters Yippee! More dummy boxes! These objects will control the emission of smoke, steam, and other evidence of damage. When your aircraft is hit, the damage system will instruct the appropriate emitter to belch forth. Notwithstanding the work that is yet to be done in the XDP file, creating the emitters is simple enough. Refer to the XDP file of any AvHistory aircraft for a list of typical emitters. Note that the name of the dummy object must match the name in the XDP file. Also, effects are oriented according to the pivot point of the dummy object. Commonly used emitters include:

Emitter Name	Comments
Emitter_damage_nose	Bits and pieces flying off.
Emitter_oil	Oil leaks coming from the oil reservoir
Emitter_damage_engine1	Leaks and fires from the left engine
Emitter_fueltank	Leaks and fires from the centre fuel tank
Emitter_damage_wing_root_r	Bits and pieces flying off
Emitter_damage_wing_r	Bits and pieces flying off
Emitter_damage_wing_tip_l	Bits and pieces flying off
Emitter_damage_tail	Bits and pieces flying off
Emitter_eng0_exh_l	Displays exhaust on engine on startup.
Emitter_eng0_exh_r	Displays exhaust on engine on startup.
Emitter_damage_tail	Bits and pieces flying

*Step 12: Hierarchy* For all its glorious detail and graphical effects, my greatest frustration from CFS3 comes when frame rates start dropping to single digit levels. There's nothing like a stuttering computer to remind you that you're just jiggling a joystick and staring at a monitor. To achieve suspension of disbelief, you need to optimize your model so that it will perform well on a reasonably modern computer. The table below illustrate the various dummy nodes that are required to form an efficient hierachy.

Node	Comments
Aircraftname	This is the top node for your model.
Cockpits	All virtual cockpits link to here.
cockpit_virtual0	Virtual cockpit 0. All pieces in this VC link to here.
Damagebox_fuselage	Damageboxes either link to here or they link to a damagebox that links to here.
Aircraft_LOD_10	The leanest view of your aircraft. Maximum faces / polygons = 50 (according to gmax) or 134 (according to conventional wisdom). LOD_10 needn't include 3D objects. Instead, it can be created using 2D objects, which will drastically reduce the number of faces. Remember to include double-sided polygons for the front/back, left/right, and top/bottom.
Aircraft_LOD_100	The richest view of your aircraft. Maximum faces / polygons = 7,500-9,332. LOD_100 is required for all aircraft. However, if you have LOD_70 or LOD_90, then you will probably never get close enough to see LOD_100 from outside the aircraft. LOD_100 parts are most often seen when looking out from inside the virtual cockpits.
Aircraft_LOD_25	Lean view. Maximum faces / polygons = 500-485. Similar to LOD_10 except that this will probably include only the most significant 3D objects.
Aircraft_LOD_50	Skinny view. Maximum faces / polygons = 1,250-2,470. Often, this is the view that other players will see when they are dogfighting in close.
Aircraft_LOD_70	Moderate view. Maximum faces / polygons = 2,500-4,855. LOD_70 is the most common external view. This will be a leaner version of LOD_100 or LOD_90.
Aircraft_LOD_90	Rich view. Maximum faces / polygons = 5,000-5,559. If your model is fairly lean, skip LOD_90 and just use LOD_70 - but make sure that your LOD_100 has fewer than 5,000 faces.

The aircraft that you just finished building in step 11 is probably the LOD_100 version. However, you'll have to create simplified versions for the other levels of detail. This will entail cloning those parts that you want to include in the next lowest level of detail and then linking them to that LOD. Cloning and linking all of these parts will create a bit of a headache. To keep things straight, I suggest that you suffix each cloned part with the LOD_#. For example, if you're cloning your fuselage for LOD_90, name the new copy fuselage_90. As the LODs get progressively smaller, the aircraft will be viewed from further away. Thus, you can safely discard landing gear, slow props, cockpits, emitters, and other detailed bits. In other words, as you move further out, you'll have fewer parts to clone. You may also need to rebuild simplified versions of certain parts. The good news is that this will be a fairly quick job. You'll only need to build the fuselage, wings, and stabilizers. It will only be viewed from far away, so you don't have to match every bump and curve. You won't need to cut out the control surfaces either - saving you both time and polygons. Forget about landing gear. Include only the blurred prop out to about LOD_50. You'll probably just need two versions of the major parts: the higher-resolution version that you created originally and the lower- resolution version you created in this step. For each of the LODs, it's just a matter of mixing and matching parts until you get what you need. One last thought: you may not need all six LODs. If you build your aircraft quite lean, then LOD_10, LOD_50, and LOD_100 may suffice. LOD_10 would include your simplified parts, LOD_50 would be your complete aircraft minus landing gear, cockpits, and other details, and LOD_100 would be the complete aircraft. Just make sure that LOD_100 doesn't exceed the LOD_70 limit and that LOD_50 doesn't exceed the LOD_25 limit. Otherwise, your model will perform poorly.

Step 13: Texture Design
Before you begin painting your aircraft, you'll need to create a wireframe diagram of the pieces of the aircraft. Once you've created the wireframe diagram, you'll simply paint over top of it - the wireframe will help you judge where the wingtips end, for example. Remember to keep a copy of the unpainted wireframe handy, just in case somebody wants to do a repaint of one of your models.

The simplest way to create a wireframe diagram is to take a bunch of screenshots of each of your parts. You'll need top and bottom screenshots for the wings, left and right shots for the fuselage, and so forth. For each screenshot, you'll press "Prnt Scrn" and then paste into your graphics program. Next, you'll clean up the screenshots by removing the background colour so that you're left with a bunch of wireframe mesh.

Generally, the screenshots of your external parts should all be proportionately sized, although you may elect to use a closer view for some of the smaller components that require more detail. Similarly, the virtual cockpit parts should also be proportionate to each other. The easiest way to maintain proportionality between separate screenshots is to capture them all from the same viewport but without changing scale or zooming in between screen captures.

A few points to bear in mind:

Wirefreame files must be square and binary-sized. The most common size is 1024x1024. Some models use 2048x2048.
Take one combined SC of the nose, fuselage, and vertical tail. Ditto for the wings, wingtips, flaps, and ailerons. However, you'll need to take an extra SC of the flaps to map the upper surfaces - which are often different from the tops of the wings.
If you want certain parts to have more detail, use larger screenshots for them.
Capture separate views of the top/front/side of high-detail virtual cockpit parts.
Arrange the parts on the file so as to use the fewest files possible. Look at other DDS files for ideas.
Virtual cockpit pieces should be mapped to a file called <aircraft model name>_c.bmp. If you need extra space, you can have multiple files called c1, c2, etc.
External pieces should be mapped to a single file called <aircraft model name>_t.bmp. If you use more than one 't' sheet, the painters won't be able to fit a Mosaic damage file to your aircraft later on.
Make a copy of your 't' sheet and name it <aircraft model name>_s.bmp. This will be your specular sheet, which painters will use to control the 'shininess' of your external surfaces.
Reserve a small box in one of the files for the window texture. Draw a box around it so that the painters don't accidentally paint over top of it. Generally, this box will remain clear.

Before you begin painting, jump to Step 14 to apply the wireframe images to your model.

From here on in, it's just a matter of painting all of the parts so that they look right to you. Save your wireframe original somewhere safe and make a new copy to do the actual painting. When painting, remember to leave a bit of overlap at the edges.

For a good tutorial on the whole screen capture process, see Hugh Shoult's "The Stupid Idiots' Guide to starting with gmax" at http://www.simviation.com/gryphon/tutorials/gMax_00.htm.

Step 14: Texture Mapping
Now that you've created your wireframe bitmaps, it's just a matter of applying them to the parts. First, you'll create textures within gmax (which are just combinations of bitmaps and settings, like opacity). Use the Material Navigator as we did in the tutorial.

To create a texture in gmax, open the Material Editor. Click New, click the box next to Diffuse, click Bitmap, click Open, and select your bitmap. For exterior textures, you will also want to add a Specular Level which will be your 's' bitmap. You'll also want to click the tiny blue buttom that says 'Show Map in Viewport', which lets you see your bitmap in gmax - eventually. Close the Material Editor.

By the way, the editor won't usually let you rename a texture when you first create it, so just configure it, save it, close the window, and then open it again to rename it. If you mess up the configuration, just delete the material and start over.

Cockpit 1: Diffuse = <aircraft model name>_c1.bmp.
Cockpit 2: Diffuse = <aircraft model name>_c2.bmp if needed. Fighters usually just need one.
Damage: Diffuse = damage_luft.bmp. Convert the shared file, damage_luft.dds, into a bitmap by using the DxtBMP utility. You'll use this texture for your endcaps.
Exterior: Diffuse = <aircraft model name>_t.bmp Specular Level = <aircraft model name>_s.bmp Do not confuse 'Specular Level' with 'Specular Color'.
Prop: Diffuse = prop_german.bmp. You'll need to convert the shared file, prop_german.dds, into a bitmap first by using the DxtBMP utility. Alternatively, you could just borrow (using the Merge function) the 3-bladed prop from the sample Ju-88 or the 4-bladed prop from the sample P-47.
Window: Diffuse = <aircraft model name>_t.bmp assuming that you placed your 'window box' on the 't' sheet. Also, set Opacity to 10.

Applying textures is the next and final step. When it comes to texturing, gmax thinks of this as holding a bitmap over top of an object and then letting the fixels 'project' onto the part. In doing so, it will let you make the image larger or smaller and it will let you move it around and rotate it as well. Let's take this process one step at a time.

Step 1 - Apply the Texture
Click on the part, select the Material Navigator, find the right texture, click on it to open the Material Editor, and then click 'Apply'. This will assign the texture to that part. If you like, select several parts and assign them the same texture at once.

Step 2 - Add a Poly Select Modifier
Whether your part is a shape (e.g. box), a mesh object, a poly object, or whatever, you should add a Poly Select modifer to the stock. This will allow you to select all or part of the polygons to be textured. You don't have to add a Poly Select but if you don't include one then the entire part will be textured automatically. Don't worry if you're part looks untextured. We'll get there in a moment.

Once you've added the Poly Select, open the roll-down and select 'Polygon'. Then, you can either fence the entire object to select all of the polygons or you can just pick-and-click the polygons that you want to be textured. As an example, when I'm texturing the wings, I'll use a Poly Select to grab all of the polygons to texture the underside of the wing. Once that's done, I'll go back and add another Poly Select to grab all of the top-facing polygons. This approach ensures that all of the polygons were textured but it also allows me to make sure that each polygon was textured correctly.

Step 2 - Add a UVW Map Modifier
This is the modifier that makes things start to appear. The UVW controls the size and projection origin (i.e. from left, from top, from back) of your image. Unfortunately, you'll need to do a little math to get everything to show up correctly. Remember how I recommended that you take screen captures of parts using the same window? We did that so that many of your parts would share the same proportional sizing. It also means that they'll be able to use the same UVW Map parameters. In short, the more parts that you captured from the same viewport (without changing scale or zooming), the fewer calculations you'll need to do!

Here's how you do the math.

You probably used the same viewport to capture most of your exterior parts such as the fuselage, wings, tail, etc. So you only need to measure one part. Pick something big, like the length of the entire fuselage from the tip of the nose to the tail. (This is just the distance along the Y axis. You don't need to calculate the hypoteneuse!) Let's call this Part Length and let's assume that Part Length = 9.25 meters.
Quick, how big is your bitmap? It's probably 1024x1024, right? Let's call this Bitmap Size and let's assume that Bitmap Size = 1024.
Lastly, open up your bitmap and measure the length in pixels of your part. However, bitmaps are funny things in that the bitmap lines are much thicker than your lines in gmax. To compensate, count the length in pixels and then subtract one. Basically, we're assuming that only half of the bitmap lines will hit our parts. We can also adjust this later. Let's call this Part Bitmap Length and let's assume that Part Bitmap Length = 749 - 1 = 748.
The number to enter in the 'Length' and 'Width' windows of the UVW Map = Bitmap Size / Part Bitmap Length * Part Length. In this case, 1024 / 748 * 9.25 = 12.663. Enter 12.663 in each of the windows.

At this point, you may see something but it probably won't look quite right. Fiddle with the 'Alignment' section of the UVW Map modifier until you see a big orange box surrounding your object. You only have three choices, X, Y, and Z.

Step 3 - Add an Unwrap UVW Modifier
This modifier will allow you to line up the part with the proper section of the bitmap. After you've added it, click on 'Edit' down below. You'll see your bitmap and a ghostly white wireframe of your part. Use your mouse to fence the part and then slide it and rotate it until it lines up properly with its section of the bitmap. Zoom in to make sure that it is aligned correctly.

If you've calculated your UVW coordinates correctly, then the part will precisely match the size of the wireframe part. If you need to adjust things, just go back and edit the UVW Map coordinates. Also, make a note of the correct numbers as you will likely use them for other parts.

That's pretty much it. Once you've mapped some of the polygons of a particular part, you can add another Poly Select, another UVW Map, and another Unwrap UVW to map some other parts. It's not unheard of to see stacks of ten or more modifers for a single part.

For a good tutorial on basic texturing, get Milan Lisner's "gmax Texturing Tutorials Part 2". You'll find it at http://www.freeflightdesign.com/tutorials.html.

Step 15: Exporting to CFS3
It doesn't take much to export your aircraft to CFS3. Before you do, I recommend that you save your current version. Next, rotate the aircraft in the TOP view so that the nose is pointing up. Then, select File and Export.

Two warnings will often appear during exports. The first relates to scaling. If you encounter these errors, just reset the scale for those parts on the Hierarchy menu, as we did in the tutorial. The second error relates to duplicate part names. In this case, you'll need to rename the parts.

When you're in CFS3, perform as many checks as you can think of, paying particular attention to the animation of control surfaces, gun flashes, and so forth. In addition, look closely at the textures you've applied. If they're distorted, then you may need to re-apply them.

Step 16: The Flight Model
When I first started modeling, I had to build my own flight models. Since then, I've been fortunate enough to have AvHistory prepare my flight models. As this is a science unto itself, I heartily recommend getting AvHistory's help. However, if you just love to tinker with this stuff, you can always use Jerry Beckwith's FDWB. Here are my notes:

The Data Tab:
Most of your inputs will go here. Also, as there are interdependencies between many of the data, you won't get an 'answer' out of the workbook until you've filled in everything. Most of the cells are self-explanatory. If you need help, refer to the notes below or look at the sample workbook that you first obtained. I've included several recommendations but these are based on my experiences working with early-WWII French aircraft.

As you go through, it is a good idea to document your rationale behind each choice. Do this on a separate file. If you're serious about accurate performance, you need to present facts that can easily be vetted by others. While you're at it, use a similar AvHistory aircraft as a baseline; you'll find much of the data listed in the support.t

Select this object . . .	. . . and link it to this object
Airspeed_Needle0	Instrument_Panel0
Instrument_Panel0	Cockpit_Floor0
Pilot0	Cockpit_Floor_Ext
Eyepoint0, Cockpit_Floor0	Cockpit_Virtual0
Cockpit_Virtual0	Cockpits
Gun_Grp0B0, R_Gear_1	R_Wing
Gun_Grp1B0, L_Gear_1	L_Wing
DamageBox_R_Wing DamageBox_L_Wing	DamageBox_Fuselage
R_Wing, L_Wing R_Elevator, L_Elevator, Rudder Cockpit_Floor_Ext, Cockpit_Window_Ext, C_Tire_Still	Fuselage
Fuselage, Cockpits, DamageBox_Fuselage	MyUglyAircraft