Introduction to X file loading {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

This page describes how you can load mesh data in the x file format maintaining a mesh hierarchy. If you are not interested in keeping the hierarchy you can simply use the D3DXLoadMeshFromX set of functions that are described in the X File Simple notes. However if you wish to implement animation or skinning you will need to read on. These notes are meant to be read in conjunction with the demo application.

Note that if you do not wish to implement this code I have written a small library to do it for you. See the XAnimator page.

Demo Application (with source code) {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

New: updated August 2010 to include some fixes I discovered while creating XAnimator. These include the ability to handle multiple skinned mesh and some bug fixes

Updated demo code download: XFileAnimationCode.rar

The demo has the following features

• Loads x files and maintains their hierarchy (press L to load)

• Handles animation and allows merging between animations.

• Handles skinning with software rendering.

The bouncy skinned model was created using 3DS Max. The process of creating it and exporting it as a DirectX x file is described in more detail here: Art Creation.The demo has a couple of limitations: it does not load effect files that are referenced in the x file and it does not do hardware skinning (it uses software skinning).

Contents {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

• Hierarchy Concept

• Loading the x file

• Rendering the hierarchy

• Animation

• Skinning

• Art Creation

• Final Words

• Further Reading

Hierarchy Concept {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

In order to animate our 3D models we need to maintain a model hierarchy. The hierarchy consists of frames containing matrix and mesh data for different parts of the model (when skinning these frames are seperate from the mesh and known as bones).

E.g. if we had a 3D model of the human body it might be divided into head, body, arms and legs. The body might be the top frame with each part in frames below defining their own matrix and mesh data. The frame matrix provides the offset position and orientation from the body matrix.

———————————————————————————–

Ignoring the legs and head the hierarchy for the above may look like this:

————————————————————————————————————-

\

When rendering we start from the top and recursively travel down through the hierarchy. Each frame has an associated matrix, so you can see that by altering the rotation of the left arm frame all the upper and lower arm are also rotated. Note: in skinning frames are called bones and there tends to be just one mesh controlled by these bones.

When the model is positioned in the 3D world the first frame (known as the root) is transformed to the correct position. Each part of the model is positioned based on the frame matrix translating and rotating it from the frame above. By maintaining this structure we can animate parts of the model simply by altering one frame matrix. We could name frames in our 3D package and then use the names in our code to find the correct frames to animate. Alternatively we can create animation in our 3D package and load it into our game and use the D3DX helper functions to animate it. This process is described in LINK below.

Loading the X File {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

The main method for loading animation data, skin info and hierarchy is D3DXLoadMeshHierarchyFromX.

Note: there is another similar function called D3DXLoadSkinMeshFromXof which loads from a ID3DXFileData object. We could load the x file data into our own formats and bypass the Direct3D functionality using this object and the ID3DXFileEnumObject. This method is not covered by these notes but if you interested there is an article on Gamedev about this (see further reading).

The D3DXLoadMeshHierarchyFromX function {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

HRESULT D3DXLoadMeshHierarchyFromX( \ LPCTSTR Filename, \ DWORD MeshOptions,\ LPDIRECT3DDEVICE9 pDevice,\ LPD3DXALLOCATEHIERARCHY pAlloc,\ LPD3DXLOADUSERDATA pUserDataLoader,\ LPD3DXFRAME* ppFrameHeirarchy,\ LPD3DXANIMATIONCONTROLLER* ppAnimController );

• Filename - the file name of the .x file to be loaded

• MeshOptions - various options can be specified here defining creation.

• pDevice - a D3D Device pointer.

• pAlloc - allows you to specify a class that will handle the allocation of memory for all the frames and mesh data. More on this below.

• pUserDataLoader - as mentioned previously the .x file format is highly flexible using a template system to define data chunks. If you add your own templates you can specify a class here that knows how to load your specific data. If you do not use this then you can ignore it and set it to 0.

• ppFrameHeirarchy - once loading complete this points to the top of the loaded frame hierarchy.

• ppAnimController - once loading complete this points to an animation controller containing animation data loaded from the x file (if it has any). The animation section describes this.

Before calling this function we need to create a ID3DXAllocateHierarchy** **derived class to handle the creation of memory for our frame and mesh data. This is where a lot of our work will take place. ID3DXAllocateHierarchy is an interface class that defines the functions we must implement. We must implement the following functions:

2. CreateFrame - requests allocation of a frame object

4. CreateMeshContainer - requests allocation of a mesh container object

6. DestroyFrame - deallocation of frame object

8. DestroyMeshContainer - deallocation of mesh container object

These will be called during the internal processing of the x file carried out by the D3DXLoadMeshHierarchyFromX function. The header for our class will look like this:

class CMeshHeirarchy : public ID3DXAllocateHierarchy\ {\ public:\ // The format of these interfaces is defined by D3DXLoadMeshHierarchyFromX\ \ // callback to create a D3DXFRAME derived object and initialize it\ STDMETHOD( CreateFrame )( THIS_ LPCSTR Name, LPD3DXFRAME *ppNewFrame );\ \ // callback to create a D3DXMESHCONTAINER derived object and initialise it\ STDMETHOD( CreateMeshContainer )( THIS_ LPCSTR Name, CONST D3DXMESHDATA *pMeshData, CONST D3DXMATERIAL * pMaterials, CONST D3DXEFFECTINSTANCE * pEffectInstances, DWORD NumMaterials, CONST DWORD * pAdjacency, LPD3DXSKININFO pSkinInfo, LPD3DXMESHCONTAINER * ppNewMeshContainer );\ \ // callback to release a D3DXFRAME derived object\ STDMETHOD( DestroyFrame )( THIS_ LPD3DXFRAME pFrameToFree );\ \ // callback to release a D3DXMESHCONTAINER derived object\ STDMETHOD( DestroyMeshContainer )( THIS_ LPD3DXMESHCONTAINER pMeshContainerToFree );\ };

The implementation of each of these functions is described below and can be seen, in full, in the sample code.

CreateFrame {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

This function is called during processing of the .x file by the D3DXLoadMeshHierarchyFromX call when a new frame is encountered. If you look back at the diagram above you can see that a frame contains either other frames (children or siblings,which is accessed by pFrameFirstChild or pFrameSibling) and / or the mesh data itself(stored in pMeshContainer). By maintaining this hierarchy we can carry out animation and other functions on our mesh data.

This function is called with a frame name and requires us to create a frame in memory. This memory is returned to the caller via the ppNewFrame parameter. Therefore we will need to look at this frame structure in more detail.

The D3DXFRAME Structure

This is a structure provided by Direct3D to hold information for a frame in our hierarchy. It contains all the basic data required:

• LPSTR Name - the frame name

• D3DXMATRIX TransformationMatrix - a transformation matrix that should be applied to this and child frames

• LPD3DXMESHCONTAINER pMeshContainer - if this frame has mesh data this will point to a container of mesh data.

• D3DXFRAME *pFrameSibling - if this frame has a sibling this points to it

• D3DXFRAME *pFrameFirstChild - if this frame has a child this points to it

When we come to render our mesh hierarchy we will traverse the frame tree applying each frame transformation matrix and rendering our mesh data. We will combine transformation matrix as we go down the hierarchy. This allows us to, for example, move the top part of the arm and have the lower part and hand and fingers all transform accordingly. It is useful therefore to also maintain a combined transformation matrix per frame (updated during our FrameMove function). This information is not held in the frame structure but we can extend the structure ourselves and add this bit of data:

struct D3DXFRAME_DERIVED: public D3DXFRAME\ {\ D3DXMATRIXA16 exCombinedTransformationMatrix;\ };

You could of course add more data if required for a particular purpose.

Note: Direct3D provides a number of functions for working with frame hierarchies like D3DXFrameDestroy,
D3DXFrameFind,D3DXFrameCalculateBoundingSphere etc.

CreateMeshContainer {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

This function is called during processing of the x file by the D3DXLoadMeshHierarchyFromX call when mesh data is encountered. This function is called with a large number of parameters:

HRESULT CreateMeshContainer(\ LPCSTR Name,\ const D3DXMESHDATA *pMeshData,\ const D3DXMATERIAL *pMaterials,\ const D3DXEFFECTINSTANCE *pEffectInstances,\ DWORD NumMaterials,\ const DWORD *pAdjacency,\ LPD3DXSKININFO pSkinInfo,\ LPD3DXMESHCONTAINER *ppNewMeshContainer);

• Name - name of the mesh

• pMeshData - pointer to a mesh data structure containing details on this mesh

• pMaterials - an array of material structures describing the materials used by this mesh

• pEffectInstances - array of effect instance structures used by this mesh

• NumMaterials - number of materials in the mesh

• pAdjacency - array of adjacency information for the mesh

• pSkinInfo - if the mesh uses skinning this points to an ID3DXSkinInfo object containing skinning data

• ppNewMeshContainer - once we have created a mesh container we return the pointer via this parameter

All but the last parameter are input data defining the mesh. Our function needs to take this data and create and return a new mesh container structure. This is a Direct3D provided structure and is described below:

The D3DXMESHCONTAINER structure

This is a structure provided by D3D to hold information about a mesh in our hierarchy. The data is:

• LPSTR Name - the mesh name

• D3DXMESHDATA MeshData - a structure containing the mesh triangle data itself in one of the D3DX mesh interface objects (ID3DXMesh, ID3DXPMesh orID3DXPatchMesh)

• LPD3DXMATERIAL pMaterials - array of mesh materials (we will not use this) *

• LPD3DXEFFECTINSTANCE pEffects - array of effect instances

• DWORD NumMaterials - number of materials

• DWORD *pAdjacency - adjacency information

• LPD3DXSKININFO pSkinInfo - skinning information

• D3DXMESHCONTAINER *pNextMeshContainer - pointer to a sibling mesh structure

It is our responsibility to allocate and fill out this structure. It is not as complex as it may look at first as a lot of this information can be directly copied from the data that is passed to us. Note: we must make a copy of this data i.e. we must leave the caller data alone.

MyView:so ga, each bone node container multiply meshes, which is stored in D3DXMESHCONTAINER(it is a container of meshes.), and each frame has a sibiling or child.

As with the D3DXFRAME structure we can add more information to this structure based on our application needs. We will normally load any textures specified for this mesh and so the addition of a texture pointer is useful. Other information commonly added includes skinning data. The structure used in the demo is shown below:

struct D3DXMESHCONTAINER_EXTENDED: public D3DXMESHCONTAINER\ {\ IDirect3DTexture9** exTextures; // Array of texture pointers \ D3DMATERIAL9* exMaterials; // Array of materials\ \ // Skinned mesh variables\ ID3DXMesh* exSkinMesh; // The skin mesh\ D3DXMATRIX* exBoneOffsets; // The bone matrix Offsets\ D3DXMATRIX** exFrameCombinedMatrixPointer; // Array of frame matrix\ };

The base D3DXMESHCONTAINER has a pMaterials member which is a D3DXMATERIAL structure that contains a texture filename and material data. It is easier to ignore this and instead store the data in arrays of created textures and materials in our derived structure (exTextures and exMaterials).

The final three variables are for skinning purposes only and are described in the section on skinning below.

DestroyFrame and DestroyMeshContainer {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

These functions should deallocate the memory we created in the above two functions. They are invoked when we destroy the frame hierarchy. This is achieved using the D3DXFrameDestroy function. Look at the demo code for the implementation.

Rendering the Hierarchy {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

After loading the x file we have our hierarchy loaded in as a tree of frames and mesh data (like the diagram). We hold a pointer to the top of our frame hierarchy (returned from D3DXLoadMeshHierarchyFromX in the ppFrameHeirarchy \ pointer). In addition, if our x file contained animation, we have a pointer to an animation controller (returned from \ D3DXLoadMeshHierarchyFromX in the ppAnimController pointer).

I will look first at how we can render this hierarchy without animation or skinning. I will talk about animation and skinning later.

Rendering the Hierarchy {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

To render the model with a hierarchy involves traversing the hierarchy maintaining matrix and rendering mesh as we encounter them. At regular intervals the demo calls CXFileEntity::UpdateFrameMatrices in order to calculate the combined matrix for each frame in the hierarchy. This could be done in the render function itself but later on we will also want to handle animation so we keep this separate.

The function Render simply calls DrawFrame with the topmost frame in the hierarchy. DrawFrame renders any mesh that it owns via a call to DrawMeshContainer. Then if the frame has any siblings it recursively calls DrawFrame with them (these calls will only return once that branch has been completed) and then any child frames.

Animation {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

As already mentioned if we have a model hierarchy we can carry out animation simply by altering a frame matrix. E.g. if we alter a shoulder matrix then the rest of the arm below will be transformed as well.

The provided x file bones_all.x contains a number of animation sets that is worth viewing while understanding these notes.

In Direct3D animation is held in animation sets maintained by an animation controller object. This is passed initially to our application in the D3DXLoadMeshHierarchyFromX function (m_animController). This controller wraps a lot of the functionality required to carry out animation.

In FrameMove we tell the animation controller what time it is by calling AdvanceTime. This allows the controller to determine the matrices for each frame in our hierarchy at that particular time. The frame controller will alter the frame matrices (the TransformationMatrix held in the frame structure) and when we update our frame hierarchy matrices during UpdateFrameMatrices we use this new matrix to create our combined frame matrix. The controller object carries out interpolation of matrix between key frames for us.

We can change which animation set is active by calling the frame controller SetTrackAnimationSet** **with the new animation set. First of all we have to retrieve this set via a call to GetAnimationSet.

Switching between animations abruptly would look wrong. Imagine our skeleton went from running to dying - the arms and legs etc, would suddenly change position. So Direct3D provides a way of interpolating into the new animation smoothly.

This is achieved via the use of tracks. Our current track is running the original animation so we use a second track for our new animation. We slowly fade out the effect of the first animation and fade in the second. We do this by inserting keys into the track using the animation controller functions. We can turn tracks on and off, change the track speed and change how much that track effects the animation (via a weighting value).

This process can be seen in the demo code SetAnimationSet function. The speed with which the transition between animations occurs is held in a global constant variable: kMoveTransitionTime. To understand how this process works try changing this value. Setting it to a higher value will slow down the transition and help you to see what is happening.

Note: the provided file bones_all.x has a number of animation sets that were added using the Mesh View tool from the SDK. If you have a number of .x files produced from an art package with the same model but different animations you can combine them into one using the Mesh View tool or do it programmatically using the animation controller \ RegisterAnimationSet unction.

Skinning {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; BACKGROUND-COLOR: #b7b4df; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 16pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

Introduction to Skinning {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

Skinning takes data in a mesh-skeleton hierarchy and applies geometry blending to transform the mesh vertices. Skinning uses a set of interconnected bones (frames) that form a hierarchy as shown above. When bones are moved or rotated the mesh surface moves or rotates accordingly (like skin does). The mesh surface is simply described with vertices forming triangles and so skinning works by altering the vertex position dependant on the bones attached to it. If you run the demo and turn on wireframe mode you can see how the vertex positions are altered.

If you think about the skin on your elbow it is affected both by the movement of the lower arm and the movement of the upper arm. Hence the position of the elbow vertices depends on two inputs (bones). The transformation of the vertices is calculated by combining a matrix from the upper arm with the one from the lower arm. How much each matrix affects each vertex is controlled by a blending weight.

Advanced: the actual geometry blending operation applies each bones matrix to the vertices to create a number of differently positioned vertices and then interpolates between them based on the blending weight.

Skinned Mesh Matrices {style=”LINE-HEIGHT: normal; WIDOWS: 2; TEXT-TRANSFORM: none; FONT-VARIANT: normal; FONT-STYLE: normal; TEXT-INDENT: 0px; FONT-FAMILY: ‘Times New Roman’, Times, serif; WHITE-SPACE: normal; ORPHANS: 2; LETTER-SPACING: normal; COLOR: #000000; FONT-SIZE: 12pt; WORD-SPACING: 0px; -webkit-text-size-adjust: auto; -webkit-text-stroke-width: 0px”}

The skeleton is a hierarchical set of bones. Each bone has a matrix which translates and rotates that bone relative to its parent (this is just the same process as the frame hierarchy discussed above but the mesh is normally separate to the hierarchy). Since the matrix are relative to the parent rather than the character itself we say they are defined in bone space. We want to place the bones relative to the character itself so must convert these matrices into character space(角色空间) by combining them with their parent matrix.

We add a variable to our extended mesh container structure for this combined matrix (called exFrameCombinedMatrixPointer- one entry per bone). Since we already maintain a combined matrix for each frame in the hierarchy (exCombinedTransformationMatrix) we do not need to duplicate it therefore our exFrameCombinedMatrixPointer is an array of pointers to the correct frames’ exCombinedTransformationMatrix. Finding the correct frame is carried out during SetupBoneMatrices using the Direct3D D3DXFrameFind function.

Combined Bone Matrix = Local Bone Matrix * Parent Combined Bone Matrix.

There is one further matrix required when doing skinning and that is a matrix to connect the bones to the mesh, this is known as a bone offset matrix. We add this to our structure as exBoneOffsets. These are assigned during the\ CMeshHierarchy::CreateMeshContainer function - one per bone. This allows us to create our final matrix:

Final Bone Matrix = Bone Offset Matrix * Combined Bone Matrix

This final matrix transforms the mesh into bone space then applies the bone matrix to the mesh. This is calculated during the frame move function and fed into the UpdateSkinnedMesh function.

Note: the amount each vertex is affected by the bones is determined by a weighting. This is contained in the ID3DXSKININFO object and is automatically calculated into the equation for us by the function UpdateSkinnedMesh.

To summarise this rather complicated process: we have a mesh that needs to be altered based on a skeleton hierarchy of bones (frames). Each bone is positioned and oriented to its parent via a local bone matrix. We store a pointer to the correct frames combined matrix in our mesh container structure (exFrameCombinedMatrixPointer). In order to wrap the mesh skin around the bones we use a bone offset matrix. By combining these two matrices we can create a final matrix that can be fed into the Direct3D UpdateSkinnedMesh function. This function will alter the mesh vertices based on the matrix and a set of weights to carry out the actual skinning.

Skinning Mesh Rendering

There are a number of methods of carrying out skinning with Direct3D. The demo code uses software skinning but there are other methods that use hardware acceleration for greater speed. The Skinned Mesh sample that comes with the DirectX SDK describes three other methods: Fixed Function Non Indexed Skinning, Fixed Function Indexed Skinning and Shader Based Skinning.

The software skinning method used by the demo is carried out in FrameMove. The process is:

/* Create the bone matrices that transform each bone from bone space into character space (via exFrameCombinedMatrixPointer) and also wraps the mesh around the bones using the bone offsets in exBoneOffsetsArray */\ \ for (UINT i = 0; i < Bones; ++i)\

D3DXMatrixMultiply(&m_boneMatrices[i],&pMesh->exBoneOffsets[i],</span>

pMesh->exFrameCombinedMatrixPointer[i]);\ \ void *srcPtr;\ pMesh->MeshData.pMesh->LockVertexBuffer(D3DLOCK_READONLY, (void**)&srcPtr);\ \ void *destPtr;\ pMesh->exSkinMesh->LockVertexBuffer(0, (void**)&destPtr);\ \ // Update the skinned mesh \ pMesh->pSkinInfo->UpdateSkinnedMesh(m_boneMatrices, NULL, srcPtr, destPtr);\ \ // Unlock the meshes vertex buffers\ pMesh->exSkinMesh->UnlockVertexBuffer();\ pMesh->MeshData.pMesh->UnlockVertexBuffer();

We lock the vertex buffer of our original unaltered mesh for read. We also lock the vertex buffer of the destination mesh vertices to write into (this is why we stored a copy of the mesh in our D3DXMESHCONTAINER_EXTENDED structure. It was copied during SetupBoneMatrices). We then call the Direct3D UpdateSkinnedMesh function which takes the transformation matrices and our locked vertex buffers and carries out the skinning. It does this by combining the matrix and a set of bone weights to alter the position of the original vertices and write them into the output buffer.

Locking vertex buffers is to be avoided as much as possible if we want our graphic card to work at maximum speed. A lock can cause a stall in the graphics processing leading to slow down. To avoid this there are a number of methods that use the hardware to carry out the skinning itself. As previously mentioned these methods are beyond the scope of these notes (for the time being - I may add notes on them later) and if you are interested I suggest you look at the skinned mesh sample that comes with the DirectX SDK.