Loading Skinned Meshes from .X
Loading a skinned mesh from an .X file is much like loading a standard mesh.
Using a custom .X parser, you must enumerate your .X file objects using
ParseObject. When it comes to processing a Mesh object, instead of calling the
D3DXLoadMeshFromXof function to load the mesh data, you call the
D3DXLoadSkinMeshFromXof function, which takes one additional parameter−a pointer
to an ID3DXSkinInfo object. Check out the D3DXLoadSkinMeshFromXof prototype to
see what I mean.
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.
D3DXERR_INVALIDDATA E_OUTOFMEMORY
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.
When you are ready to load a mesh from an enumerated Mesh template, call the
D3DXLoadSkinMeshFromXof function instead of calling D3DXLoadMeshFromXof. Make
sure to supply an ID3DXSkinInfo object where it is shown in the prototype.
Whether or not the Mesh template contains a skinned mesh doesn't matter−the
D3DXLoadSkinMeshFromXof function will load regular and skinned meshes without a
hitch. Here's an example:
// Define the mesh and skinned mesh info objects
ID3DXMesh *pMesh;
ID3DXSkinInfo *pSkinInfo;
// Define buffers to hold the material data and adjacency data
ID3DXBuffer *pMaterialBuffer = NULL, *pAdjacencyBuffer = NULL;
// DWORD to hold the number of materials being loaded
DWORD NumMaterials;
// Load the skinned mesh from IDirectXFileDataObject pDataObj
D3DXLoadSkinMeshFromXof(pDataObj, D3DXMESH_SYSTEMMEM, pDevice,
&pAdjacencyBuffer,
&pMaterialBuffer, NULL, &NumMaterials, &pSkinInfo, &pMesh);
Just because you used the D3DXLoadSkinnedMeshFromXof function, that doesn't
mean a skinned mesh was loaded. First you need to check the pSkinInfo object. If
it's set to NULL, then a skinned mesh wasn't loaded. If it's a valid object
(non−NULL), then you need to check whether any bones exist.
The easiest way to see whether bones exist is to call
ID3DXSkinInfo::GetNumBones. The GetNumBones function will return the number of
bones loaded from the Mesh template. If the number is 0, then there are no
bones, and you can free the ID3DXSkinInfo object (using Release). If bones do
exist, then you can continue using the skinned mesh.
Check out this example, which tests whether a skinned mesh was loaded. If so,
the example checks to see whether the mesh contains any bones.
// Set a flag is there's a skinned mesh and bones to use
BOOL SkinnedMesh = FALSE;
if(pSkinInfo && pSkinInfo−>GetNumBones())
SkinnedMesh = TRUE;
else
{
// Free the skinned mesh info data object
if(pSkinInfo)
{
pSkinInfo−>Release();
pSkinInfo = NULL;
}
}
If the SkinnedMesh flag is set to TRUE, then the pSkinInfo object is valid
and you're ready to work with the skinned mesh. The next step is to create
another mesh object that will contain the actual deforming mesh as you change
the bones' orientations.
Creating a Secondary Mesh Container
After you create the skinned mesh, you need to create a second mesh
container. Why, you ask? Well, the skinned mesh object you loaded from the
D3DXLoadSkinMeshFromXof function is sort of the base of reference for your
mesh's vertex data. Since these vertices are in the right positions to match the
orientations of the bones, it would mess up things quite a bit if you started
altering those positions.
Let's leave things well enough alone and instead create a second mesh object
(an ID3DXMesh object) that contains an exact duplicate of the skinned mesh. You
need to read the vertex data from the skinned mesh data, apply the various bone
transformations, and write the resulting vertex data to this duplicate mesh
container (which I call the secondary mesh or secondary mesh container) that you
use to render. Makes sense, doesn't it?
As I mentioned, the secondary mesh is an identical match to the skinned mesh;
everything from the number of vertices to the indices needed is the same. The
easiest way to duplicate the skinned mesh object is to use the
ID3DXMesh::CloseMeshFVF function.
Clones a mesh using a flexible vertex format (FVF)
code.
HRESULT CloneMeshFVF(
DWORD Options,
DWORD FVF,
LPDIRECT3DDEVICE9 pDevice,
LPD3DXMESH * ppCloneMesh
);
Parameters
- Options
- [in] A combination of one or more D3DXMESH flags
specifying creation options for the mesh.
- FVF
- [in] Combination of FVF codes, which specifies the
vertex format for the vertices in the output mesh. For the values of the
codes, see D3DFVF.
- pDevice
- [in] Pointer to an IDirect3DDevice9 interface
representing the device object associated with the mesh.
- ppCloneMesh
- [out, retval] Address of a pointer to an ID3DXMesh
interface, representing the cloned mesh.
Return Values
If the method succeeds, the return value is D3D_OK. If
the method fails, the return value can be one of the following:
D3DERR_INVALIDCALL, E_OUTOFMEMORY.
Remarks
ID3DXBaseMesh::CloneMeshFVF is used to reformat and
change the vertex data layout. This is done by creating a new mesh object. For
example, use it to to add space for normals, texture coordinates, colors,
weights, etc. that were not present before.
ID3DXBaseMesh::UpdateSemantics updates the vertex
declaration with different semantic information without changing the layout of
the vertex buffer. This method does not modify the contents of the vertex
buffer. For example, use it to relabel a 3D texture coordinate as a binormal or
tangent or vice versa.
The Options parameter of CloneMeshFVF is just like the one from the calls to
D3DXLoadMeshFromX, D3DXLoadMeshFromXof, and D3DXLoadSkinMeshFromXof, so take
your pick. I tend to set Options flags to 0, but feel free to change it.
As for the FVF parameter, you only need to supply the FVF from the skinned
mesh object using the skinned mesh's GetFVF function. Also, don't forget to
supply the valid IDirect3DDevice9 object you are using, as well as a pointer to
an ID3DXMesh object that will be your secondary mesh container.
Here's a bit of code that demonstrates cloning a skinned mesh to create your
secondary mesh:
// pSkinMesh = ID3DXMesh object
ID3DXMesh *pMesh; // Secondary mesh container
pSkinMesh−>CloneMeshFVF(0, pMesh−>GetFVF(), pDevice, &pMesh);
All this talk of cloning reminds me of Star Wars Episode II: Attack of the
Clones. Good thing your cloned secondary meshes aren't going to try to take over
the universeor are they? Well heck, those clones aren't going anywhere without a
little effort, so let's get back to work and see what's next in line.
After you've created the secondary mesh container, it's time to map your
bones to the frame hierarchy. Why didn't we do this previously, when I was
discussing bones and frames? Easy−the bone data was loaded until you called
D3DXLoadSkinMeshFromXof!