Loading Meshes with Your .X Parser

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.

class cXMeshParser : public cXParser
{
public:
	ID3DXMesh *m_Mesh;
public:
	cXMeshParser() { m_Mesh = NULL; }
	~cXMeshParser() { if(m_Mesh) m_Mesh−>Release(); }

	BOOL ParseObject(IDirectXFileData *pDataObj, 
		IDirectXFileData *pParentDataObj, 
		DWORD Depth, 
		void **Data, 
		BOOL Reference);
};

As you can see from the class declaration, I'm only declaring one mesh object. If you want more, you need to create a linked list (or another type of list) to contain the mesh objects. I'll leave that up to you because for now I just want to demonstrate using the D3DXLoadMeshFromXof function.

Override the ParseObject function, allowing it to scan for Mesh objects.

BOOL cXMeshParser::ParseObject( 
	IDirectXFileData *pDataObj, 
	IDirectXFileData *pParentDataObj, 
	DWORD Depth, 
	void **Data, 
	BOOL Reference)
{
	// Skip reference objects
	if(Reference == TRUE)
		return TRUE;

	// Make sure object being parsed is Mesh
	if(*GetObjectGUID(pDataObj) == D3DRM_TIDMesh) 
	{
		// It's a mesh, use D3DXLoadMeshFromXof to load it
		ID3DXBuffer *Materials;
		DWORD NumMaterials;

		D3DXLoadMeshFromXof(pDataObj, 0, pDevice, NULL, &Materials, NULL, &NumMaterials, &m_Mesh);

		// Finish by processing material information

		// return FALSE to stop parsing
		return FALSE;
	}

	// Parse child objects
	return ParseChildObjects(pDataObj,Depth,Data,Reference);
}

There you have it! With one quick call, you've loaded a mesh from a Mesh data object! If you think that's cool, I've got something new for you−skinned meshes. Read on to see how to load skinned mesh data from .X files.

Loading Skinned Meshes

A skinned mesh contains a hierarchy of bones (a skeletal structure) that you can use to deform the mesh to which the bones are attached.

Loading skinned meshes from .X files is just like loading regular meshes. By enumerating the data objects, you can determine which ones to load skinned mesh data from and put the data into an ID3DXSkinMesh object.

The surprising thing here is that a skinned mesh's data is contained in the same Mesh objects as a regular mesh! If it's the same data object, how could you possibly know the difference between a skinned mesh and a regular mesh?

The only way to determine whether a Mesh data object contains skinned mesh data is to use the D3DXLoadSkinMeshFromXof function to load the mesh into an ID3DXSkinMesh object. After the mesh data is loaded, you can query the newly created skinned mesh object to see whether it contains bone information (which is contained in special data objects embedded within the Mesh object). If bone
information exists, the mesh is skinned. If no bones exist, the mesh is regular and can be converted to an ID3DXMesh object.

I'm starting to get ahead of myself, so jump back to the whole ID3DXSkinMesh and D3DXLoadSkinMeshFromXof thing.Much like regular meshes, you must instance an ID3DXSkinMesh object.

ID3DXSkinMesh *SkinMesh = NULL;

Inside your ParseObject function, you need to change the D3DXLoadSkinMeshFromXof call. Instead of calling D3DXLoadMeshFromXof this time, use D3DXLoadSkinMeshFromXof.

Loads a skin mesh from a DirectX .x file data object.

HRESULT D3DXLoadSkinMeshFromXof(
  LPD3DXFILEDATA pxofMesh,
  DWORD Options,
  LPDIRECT3DDEVICE9 pD3DDevice,
  LPD3DXBUFFER * ppAdjacency,
  LPD3DXBUFFER * ppMaterials,
  LPD3DXBUFFER * ppEffectInstances,
  DWORD * pMatOut,
  LPD3DXSKININFO * ppSkinInfo,
  LPD3DXMESH * ppMesh
);

Parameters

pxofMesh

[in] Pointer to an ID3DXFileData interface, representing the file data object to load.

Options

[in] Combination of one or more flags, from the D3DXMESH enumeration, specifying creation options for the mesh.

pD3DDevice

[in] Pointer to an IDirect3DDevice9 interface, the device object associated with the mesh.

ppAdjacency

[out] Address of a pointer to an ID3DXBuffer interface. When this method returns, this parameter is filled with an array of three DWORDs per face that specify the three neighbors for each face in the mesh.

ppMaterials

[out] Address of a pointer to an ID3DXBuffer interface. When the method returns, this parameter is filled with an array of D3DXMATERIAL structures.

ppEffectInstances

[out] Pointer to a buffer containing an array of effect instances, one per attribute group in the returned mesh. An effect instance is a particular instance of state information used to initialize an effect. See D3DXEFFECTINSTANCE. For more information about accessing the buffer, see ID3DXBuffer.

pMatOut

[out] Pointer to the number of D3DXMATERIAL structures in the ppMaterials array, when the method returns.

ppSkinInfo

[out] Address of a pointer to an ID3DXSkinInfo interface, which represents the skinning information.

ppMesh

[out] Address of a pointer to an ID3DXMesh interface, which represents the loaded mesh.

Return Values

If the function succeeds, the return value is D3D_OK. If the function fails, the return value can be one of the following: D3DERR_INVALIDCALL.

Remarks

This method takes a pointer to an internal object in the .x file, enabling you to load the frame hierarchy.

For mesh files that do not contain effect instance information, default effect instances will be generated from the material information in the .x file. A default effect instance will have default values that correspond to the members of the D3DMATERIAL9 structure.

The default texture name is also filled in, but is handled differently. The name will be Texture0@Name, which corresponds to an effect variable by the name of "Texture0" with an annotation called "Name." This will contain the string file name for the texture.

I know you've got to be saying that D3DXLoadSkinMeshFromXof looks almost exactly like D3DXLoadMeshFromXof, and you're right! Loading the skinned mesh using D3DXLoadSkinMeshFromXof looks something like this:

D3DXLoadSkinMeshFromXof(pDataObj, 0, pDevice, NULL, &Materials, NULL, &NumMaterials, &SkinMesh);

Once you have called D3DXLoadSkinMeshFromXof using a valid Mesh object, you'll have a cool new ID3DXSkinMesh object at your disposal.

ParseMesh Demo

ParseMesh contains a button (shown in Figure 3.3) that you click to locate and open an .X file.

Figure 3.3: After locating and opening an .X file, you are shown some vital data on each mesh contained in that file.

The ParseMesh demo lists information about the meshes it finds in the .X file you opened. This data includes the type of mesh (standard or skinned), the number of vertices, the number of faces, and (when applicable) the number of bones. You can use this handy demo program as an example for your own .X file, to make sure all the meshes contain the proper information.

Because IDirectXFile interface has been deprecated, I translate this interface into ID3DXFile.

XParser.h:

download source file