Using the .X File Format(11) 摘要: Skeletal animation systems require
a frame hierarchy (which represents the bone structure) to orient each bone
during rendering. The .X file format defines a frame−of−reference data
template that you can use to define your bone hierarchy. This template,
Frame, is merely a placeholder of sorts. It allows any type of data object
to be embedded in it so you can reference the instanced Frame object by its
assigned instance name and allow all contained objects to be addressed as
well.
Using the .X File Format(10) 摘要: Just as I promised, it's time to
check out how to merge the mesh−loading functions into your .X parser class.
Since you're going to be accessing the mesh data objects directly, you need
to use the D3DXLoadMeshFromXof function to load mesh data. That means you
need to parse each data object, and look for Mesh objects as you go. Start
by deriving a parser class with which to work.
Using the .X File Format(9) 摘要: Now that you've got a firm grip on
how the .X file format works, consider how Microsoft first intended for you
to use it−to contain 3D mesh information for your games. The D3DX library
comes with a number of functions you can use to load mesh data from an .X
file. With the addition of the .X parser developed in this chapter, you have
even more options available to you. Check out just how easy it is to work
with D3DX to load mesh data.
Using the .X File Format(8) 摘要: So, you want to create a class to
handle all aspects of parsing .X files, eh? Sounds great to me! In this .X
file parser class, you can wrap up the Parse and ParseObject functions you
saw earlier in this chapter, in the "Enumerating Data Objects" section. Use
the code from those two functions and write the parser class to allow
yourself to override the data object parsing functions, which will allow you
to scan for specific objects.
Using the .X File Format(7) 摘要: Remember that data objects are
containers for data, and if you're going to the trouble to enumerate data
objects, it's a safe bet that you're after the data in each one. Once you've
got a valid IDirectXFileData object that points at an enumerated data
object, you can retrieve the object's instance name, template GUID, and data
using a trio of functions. The first function, IDirectXFileData::GetName,
retrieves the name of the data object instance.
Using the .X File Format(6) 摘要: At this point, you have opened your
.X file and registered the templates you'll be using (such as the DirectX
standard templates). The enumeration object has been created, and you are
now ready to pull data from the .X file.
In its current state, the IDirectXFileEnumObject object you created points
to the first data object in the file, which is typically the Header object.
All top−level data objects are siblings of the Header object (or the first
object in the file). Each data object yo
Using the .X File Format(5) 摘要: Regardless of the version of
DirectX you are using (either DirectX 8 or 9), the methods you use to access
.X files are the same. In fact, the interfaces have not changed names
between the two newest versions of DirectX (8 and 9), making it possible for
you to quickly port your version 8 code to the newer version 9 (and vice
versa if you want).
Using the .X File Format(4) 摘要: some .X Standard Templates:
Using the .X File Format(3) 摘要: Data referencing has one caveat−the
template restrictions set in place must allow you to use a reference. That
might not make sense at first, but you can't use a data reference without
the proper restrictions. An .X file represents an entire hierarchy of data
objects, which can only be siblings or children of other objects. Thus, data
objects embedded in other objects need the proper restrictions to be
referenced or instanced. For example, consider the following three template
declarations:
Using the .X File Format(2) 摘要: Since an .X file's open−ended
design is so, well, open−ended, you must predefine each template that you
intend to use for DirectX to understand how to access the template's data.
Typically templates are defined inside an .X file, although you can define
them from within your program (as I mentioned earlier).
Using the .X File Format(1) 摘要: 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?