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!