Your 3D meshes need a place to liverather, you need a place to store your 3D mesh data (not to mention all that other data your game project requires). What's a developer to do−develop his own file format or go with a third−party format? With so many popular formats out there, it's an easy choice to make, but what about the restrictions some formats impose? Why can't you just use somebody else's file format and configure it to work the way you want?

That somebody else is none other than Microsoft, and the format to use is .X! Now uncross those eyes, mister−those .X files are really easy to use once you understand them, and this chapter will teach you what you need to know.

Working with .X Templates and Data Objects

If you haven't already, I invite you to take a look at one of those mysterious .X files that comes packaged with the DirectX SDK (located in the \Samples\Multimedia\Media directory of your DirectX install). Go on, I dare you. More than likely, you'll be greeted with something like this:

xof 0302txt 0032

template Header {
	<3D82AB43−62DA−11cf−AB39−0020AF71E433>
	DWORD major;
	DWORD minor;
	DWORD flags;
}

template Frame {
	<3D82AB46−62DA−11cf−AB39−0020AF71E433>
	[FrameTransformMatrix]
	[Mesh]
}

Header {
	1;
	0;
	1;
}

Frame Scene_Root {
	FrameTransformMatrix {
		1.000000, 0.000000, 0.000000, 0.000000,
		0.000000, 1.000000, 0.000000, 0.000000,
		0.000000, 0.000000, 1.000000, 0.000000,
		0.000000, 0.000000, 0.000000, 1.000000;;
	}

	Frame Pyramid_Frame {
		FrameTransformMatrix {
			1.000000, 0.000000, 0.000000, 0.000000,
			0.000000, 1.000000, 0.000000, 0.000000,
			0.000000, 0.000000, 1.000000, 0.000000,
			0.000000, 0.000000, 0.000000, 1.000000;;
		}

		Mesh PyramidMesh {
			5;
			0.00000;10.00000;0.00000;,
			−10.00000;0.00000;10.00000;,
			10.00000;0.00000;10.00000;,
			−10.00000;0.00000;−10.00000;,
			10.00000;0.00000;−10.00000;;
			6;
			3;0,1,2;,
			3;0,2,3;,
			3;0,3,4;,
			3;0,4,1;,
			3;2,1,4;,
			3;2,4,3;;

			MeshMaterialList {
				1;
				6;
				0,0,0,0,0,0;;

				Material Material0 {
					1.000000; 1.000000; 1.000000; 1.000000;;
					0.000000;
					0.050000; 0.050000; 0.050000;;
					0.000000; 0.000000; 0.000000;;
				}
			}
		}
	}
}

Scary looking, isn't it? Actually, you can break down every .X file into a small handful of easy−to−manage components, which makes the files easy to understand and process. Let me explain what I mean. Every .X file starts with a small header, which in the preceding example looks like this:

xof 0302txt 0032

This small blurb of text informs programs that load the file that it is indeed an .X file. (The xof portion signifies an .X file.) It also informs programs that the file uses the DirectX .X file version 3.2 templates (represented by the 0302 text). Following the version number is txt, which signifies that all of the following .X data is stored in a text format as opposed to a binary format. The line of text ends with 0032, which defines the number of bits reserved for floating−point values (0032 for 32−bit or 0064 for 64−bit).

Note Binary, a second .X file storage format, is useful for compacting data into a format that is unreadable by humans. I won't discuss the binary format; however, the techniques used to process .X files in this chapter still apply to binary .X files, so don't worry about missing out on any good stuff!

After the file header there are a slew of data chunks, referred to as templates and data objects. You can tell the difference between a template and a data object because all templates begin with the word template. As you can see from the .X file code, templates look much like a C structure definition. Data objects are instances of those templates.

You use templates to define the information that data objects contain in the .X file. (A template defines the layout of a data object.) Each template can contain any type of data defined by a small set of data types, and any combination of data types can be used inside a template. A data object is merely an instance of a template. You can think of a template much like a C++ class−they both define the data that an instance of the object can contain.

Taking another look at the example .X file, you can see that the first template you'll encounter is Header, which is the template's class name. The Header template contains three DWORD values (as well as a large number called a GUID, which is enclosed in angle brackets), which you set when you create a data object from the template. Creating data objects is much like instancing a class or structure. In the previous .X file code, the instancing of the Header template looks like this:

Header {
  1; // major
  0; // minor
  1; // flags
}

Notice that you must define every variable contained in the Header template in your data object, and in the same order. You might be wondering about that large number (the template's GUID) defined in the template, however. What does that have to do with instancing your template? Nothing, actually, because DirectX uses that large number to identify templates as they are loaded. I'll get back to the template GUID (Globally Unique Identification Number) in a moment.

Tip Much like C/C++, you can also use the handy // operator to signify comments in your .X file.

The next template you'll see in the .X file is Frame. This is a special template−it doesn't define any data types, but it does reference other template classes. The other template classes, enclosed in square brackets, are named FrameTransformMatrix and Mesh. Using this manner of referencing other templates from within a template, you can create a hierarchy of data objects.

Also, by declaring additional templates within another template, you are creating a set of template restrictions, which enable you to create templates that only allow specific data objects to be embedded within another data object. In this case, only the data objects of the type FrameTransformMatrix and Mesh can be embedded in a Frame data object. You'll read more about template restrictions later in this chapter. For now, move on to examining the rest of the .X file.

Following the template definitions (which should also be at the beginning of the .X file) are the data objects. These are declared much like C data structures would be−you instance the structure by its template class name, followed by the data object's instance name. The instance name is optional, however, so don't worry if you come across some data objects that are missing it.

In the .X file you're examining, the first data object has an instance name of Scene_Root. The Scene_Root object is of the template class type Frame. You've already seen the Frame template defined. Looking back to that template definition, you can see that there is no data to store, but there are two optional data objects you can embed in Frame−FrameTransformMatrix and Mesh.

Just by a matter of luck, both a FrameTransformMatrix and a Mesh data object are embedded in Scene_Root. Missing from the .X file, however, are the template definitions for FrameTransformMatrix and Mesh. How are you supposed to know what data those objects contain? Well, an .X file doesn't have to define every template with the file itself−you can define those template definitions inside your program!

You'll get to see how to define these templates within your programs later in this chapter. For now, let's get back to the example. A data object of the template class type FrameTransformMatrix is embedded in the Scene_Root data object. This data object contains floating−point values that represent a transformation matrix. After that data object there is another data object of the template class type Mesh, which contains information about a mesh.

Okay, enough of this example−I'm sure you're getting the gist of it. As you can see, templates are completely user−defined, meaning that you can create any type of template to contain any type of data. Want to contain raw sound data in an .X file? How about storing heartbeat−sensor readings? Using .X, you can store sound data, heartbeat readings, and any other type of data you want!