HRESULT CCharacter::SetupBoneMatrixPointersOnMesh_(
                              LPD3DXMESHCONTAINER pMeshContainerBase)
  {
      UINT iBone, cBones;
      D3DXFRAME_DERIVED *pFrame;
  
      D3DXMESHCONTAINER_DERIVED *pMeshContainer = (D3DXMESHCONTAINER_DERIVED*)pMeshContainerBase;
  
      // if there is a skinmesh, then setup the bone matrices
      if (pMeshContainer->pSkinInfo != NULL)
      {
          cBones = pMeshContainer->pSkinInfo->GetNumBones();
  
          pMeshContainer->ppBoneMatrixPtrs = new D3DXMATRIX*[cBones];
          if (pMeshContainer->ppBoneMatrixPtrs == NULL)
              return E_OUTOFMEMORY;
  
          for (iBone = 0; iBone < cBones; iBone++)
          {
              pFrame = (D3DXFRAME_DERIVED*)D3DXFrameFind(m_pFrameRoot, pMeshContainer->pSkinInfo->GetBoneName(iBone));
              if (pFrame == NULL)
                  return E_FAIL;
  
              pMeshContainer->ppBoneMatrixPtrs[iBone] = &pFrame->CombinedTransformationMatrix;
          }
      }
  
      return S_OK;
  }
  
  
////////////////////////// CAllocateHierarchy 
/////////////////////



  
  //-----------------------------------------------------------------------------
  // Name: AllocateName()
  // Desc: Allocates memory for a string to hold the name of a frame or mesh
  //-----------------------------------------------------------------------------
  HRESULT AllocateName( LPCTSTR Name, LPTSTR *pNewName )
  {
      UINT cbLength;
  
      if (Name != NULL)
      {
          cbLength = lstrlen(Name) + 1;
          *pNewName = new TCHAR[cbLength];
  
          if (*pNewName == NULL)
              return E_OUTOFMEMORY;
  
          memcpy(*pNewName, Name, cbLength*sizeof(TCHAR));
      }
      else
      {
          *pNewName = NULL;
      }
  
      return S_OK;
  }
  
  //-----------------------------------------------------------------------------
  // CAllocateHierarchy
  // Constructor
  //-----------------------------------------------------------------------------
  CAllocateHierarchy::CAllocateHierarchy(IDirect3DDevice9* pDevice)
      : m_pDevice( NULL )
  {
      if( pDevice )
      {
          m_pDevice = pDevice;
          m_pDevice->AddRef();
      }
  }
  
  //-----------------------------------------------------------------------------
  // ~CAllocateHierarchy
  // Destructor
  //-----------------------------------------------------------------------------
  CAllocateHierarchy::~CAllocateHierarchy()
  {
      RELEASE( m_pDevice );
  }
  
  //-----------------------------------------------------------------------------
  // Name: CAllocateHierarchy::CreateFrame()
  // Desc: 
  //-----------------------------------------------------------------------------
  HRESULT CAllocateHierarchy::CreateFrame(LPCTSTR Name, LPD3DXFRAME *ppNewFrame)
  {
      HRESULT hr = S_OK;
      D3DXFRAME_DERIVED *pFrame = NULL;
  
      *ppNewFrame = NULL;
  
      try
      {
  
          pFrame = new D3DXFRAME_DERIVED;
  
          if (pFrame == NULL)
              throw E_OUTOFMEMORY;
  
          hr = AllocateName(Name, &pFrame->Name);
          if (FAILED(hr))
          {
              delete pFrame;
              throw hr;
          }
  
          // initialize other data members of the frame
          D3DXMatrixIdentity(&pFrame->TransformationMatrix);
          D3DXMatrixIdentity(&pFrame->CombinedTransformationMatrix);
  
          pFrame->pMeshContainer = NULL;
          pFrame->pFrameSibling = NULL;
          pFrame->pFrameFirstChild = NULL;
  
          *ppNewFrame = pFrame;
          pFrame = NULL;
      }
      catch( HRESULT hr1 )
      {
          if( pFrame )
          {
              delete pFrame;
              hr = hr1;
          }
      }
      return hr;
  }
  
  //-----------------------------------------------------------------------------
  // Name: CAllocateHierarchy::CreateMeshContainer()
  // Desc: 
  //-----------------------------------------------------------------------------
  HRESULT CAllocateHierarchy::CreateMeshContainer(
                                      LPCTSTR Name, 
                                      CONST D3DXMESHDATA *pMeshData,
                                      CONST D3DXMATERIAL *pMaterials, 
                                      CONST D3DXEFFECTINSTANCE *pEffectInstances, 
                                      DWORD NumMaterials, 
                                      CONST DWORD *pAdjacency, 
                                      LPD3DXSKININFO pSkinInfo, 
                                      LPD3DXMESHCONTAINER *ppNewMeshContainer) 
  {
      HRESULT hr = S_OK;
      D3DXMESHCONTAINER_DERIVED *pMeshContainer = NULL;
      UINT NumFaces;
      UINT iMaterial;
      UINT iBone, cBones;
  
      LPDIRECT3DDEVICE9 pd3dDevice = NULL;
      LPD3DXMESH pMesh = NULL;
  
      *ppNewMeshContainer = NULL;
  
      try
      {
          // this sample does not handle patch meshes, so fail when one is found
          if (pMeshData->Type != D3DXMESHTYPE_MESH)
              throw E_FAIL;
  
          // get the pMesh interface pointer out of the mesh data structure
          pMesh = pMeshData->pMesh;
  
          // this sample does not FVF compatible meshes, so fail when one is found
          if (pMesh->GetFVF() == 0)
              throw E_FAIL;
  
          // allocate the overloaded structure to return as a D3DXMESHCONTAINER
          pMeshContainer = new D3DXMESHCONTAINER_DERIVED;
  
          if (pMeshContainer == NULL)
              throw E_OUTOFMEMORY;
  
          memset(pMeshContainer, 0, sizeof(D3DXMESHCONTAINER_DERIVED));
  
          // make sure and copy the name.  All memory as input belongs to caller, interfaces can be addref'd though
          hr = AllocateName(Name, &pMeshContainer->Name);
          if (FAILED(hr))
              throw hr;        
  
          pMesh->GetDevice(&pd3dDevice);
          NumFaces = pMesh->GetNumFaces();
  
          // if no normals are in the mesh, add them
          if (!(pMesh->GetFVF() & D3DFVF_NORMAL))
          {
              pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;
  
              // clone the mesh to make room for the normals
              hr = pMesh->CloneMeshFVF(   pMesh->GetOptions(), 
                                          pMesh->GetFVF() | D3DFVF_NORMAL, 
                                          pd3dDevice, 
                                          &pMeshContainer->MeshData.pMesh );
              if (FAILED(hr))
                  throw hr;
  
              // get the new pMesh pointer back out of the mesh container to use
              // NOTE: we do not release pMesh because we do not have a reference to it yet
              pMesh = pMeshContainer->MeshData.pMesh;
  
              // now generate the normals for the pmesh
              D3DXComputeNormals( pMesh, NULL );
          }
          else  // if no normals, just add a reference to the mesh for the mesh container
          {
              pMeshContainer->MeshData.pMesh = pMesh;
              pMeshContainer->MeshData.Type = D3DXMESHTYPE_MESH;
  
              pMesh->AddRef();
          }
          
          // allocate memory to contain the material information.  This sample uses
          //   the D3D9 materials and texture names instead of the EffectInstance style materials
          pMeshContainer->NumMaterials = max(1, NumMaterials);
          pMeshContainer->pMaterials = new D3DXMATERIAL[pMeshContainer->NumMaterials];
          pMeshContainer->ppTextures = new LPDIRECT3DTEXTURE9[pMeshContainer->NumMaterials];
          pMeshContainer->pAdjacency = new DWORD[NumFaces*3];
  
          if ((pMeshContainer->pAdjacency == NULL) || (pMeshContainer->pMaterials == NULL))
              throw E_OUTOFMEMORY;
  
          memcpy(pMeshContainer->pAdjacency, pAdjacency, sizeof(DWORD) * NumFaces*3);
          memset(pMeshContainer->ppTextures, 0, sizeof(LPDIRECT3DTEXTURE9) * pMeshContainer->NumMaterials);
  
          // if materials provided, copy them
          if (NumMaterials > 0)            
          {
              memcpy(pMeshContainer->pMaterials, pMaterials, sizeof(D3DXMATERIAL) * NumMaterials);
  
              for (iMaterial = 0; iMaterial < NumMaterials; iMaterial++)
              {
                  if (pMeshContainer->pMaterials[iMaterial].pTextureFilename != NULL)
                  {
                      TCHAR strTexturePath[MAX_PATH] = _T("");
                      DXUtil_FindMediaFileCb( strTexturePath, sizeof(strTexturePath), pMeshContainer->pMaterials[iMaterial].pTextureFilename );
                      if( FAILED( D3DXCreateTextureFromFile( pd3dDevice, strTexturePath, 
                                                              &pMeshContainer->ppTextures[iMaterial] ) ) )
                          pMeshContainer->ppTextures[iMaterial] = NULL;
  
                      // don't remember a pointer into the dynamic memory, just forget the name after loading
                      pMeshContainer->pMaterials[iMaterial].pTextureFilename = NULL;
                  }
              }
          }
          else // if no materials provided, use a default one
          {
              pMeshContainer->pMaterials[0].pTextureFilename = NULL;
              memset(&pMeshContainer->pMaterials[0].MatD3D, 0, sizeof(D3DMATERIAL9));
              pMeshContainer->pMaterials[0].MatD3D.Diffuse.r = 0.5f;
              pMeshContainer->pMaterials[0].MatD3D.Diffuse.g = 0.5f;
              pMeshContainer->pMaterials[0].MatD3D.Diffuse.b = 0.5f;
              pMeshContainer->pMaterials[0].MatD3D.Specular = pMeshContainer->pMaterials[0].MatD3D.Diffuse;
          }
  
          // if there is skinning information, save off the required data and then setup for HW skinning
          if (pSkinInfo != NULL)
          {
              // first save off the SkinInfo and original mesh data
              pMeshContainer->pSkinInfo = pSkinInfo;
              pSkinInfo->AddRef();
  
              pMeshContainer->pOrigMesh = pMesh;
              pMesh->AddRef();
  
              // Will need an array of offset matrices to move the vertices from the figure space to the bone's space
              cBones = pSkinInfo->GetNumBones();
              pMeshContainer->pBoneOffsetMatrices = new D3DXMATRIX[cBones];
  
              if (pMeshContainer->pBoneOffsetMatrices == NULL)
                  throw E_OUTOFMEMORY;
  
              // get each of the bone offset matrices so that we don't need to get them later
              for (iBone = 0; iBone < cBones; iBone++)
              {
                  pMeshContainer->pBoneOffsetMatrices[iBone] = 
                          *(pMeshContainer->pSkinInfo->GetBoneOffsetMatrix(iBone));
              }
  
              // GenerateSkinnedMesh will take the general skinning information and transform it to a HW friendly version
              hr = GenerateSkinnedMesh_(pMeshContainer);
              if (FAILED(hr))
                  throw hr;
          }
  
          *ppNewMeshContainer = pMeshContainer;
          pMeshContainer = NULL;
      }// try
      catch( HRESULT hr1 )
      {
          DestroyMeshContainer(pMeshContainer);
          hr = hr1;
      }
  
      RELEASE(pd3dDevice);
      return hr;
  }
  
  //-----------------------------------------------------------------------------
  // Name: CAllocateHierarchy::DestroyFrame()
  // Desc: 
  //-----------------------------------------------------------------------------
  HRESULT CAllocateHierarchy::DestroyFrame(LPD3DXFRAME pFrameToFree) 
  {
      if( pFrameToFree->Name )
      {
          delete[] pFrameToFree->Name;
          pFrameToFree->Name = NULL;
      }
      if( pFrameToFree )
      {
          delete pFrameToFree;
          pFrameToFree = NULL;
      }
      return S_OK; 
  }
  
  //-----------------------------------------------------------------------------
  // Name: CAllocateHierarchy::DestroyMeshContainer()
  // Desc: 
  //-----------------------------------------------------------------------------
  HRESULT CAllocateHierarchy::DestroyMeshContainer(LPD3DXMESHCONTAINER pMeshContainerBase)
  {
      UINT iMaterial;
      D3DXMESHCONTAINER_DERIVED *pMeshContainer = (D3DXMESHCONTAINER_DERIVED*)pMeshContainerBase;
  
      if( pMeshContainer->Name )
      {
          delete[] pMeshContainer->Name;
          pMeshContainer->Name = NULL;
      }
  
      if( pMeshContainer->pAdjacency )
      {
          delete[] pMeshContainer->pAdjacency;
          pMeshContainer->pAdjacency = NULL;
      }
  
      if( pMeshContainer->pMaterials )
      {
          delete[] pMeshContainer->pMaterials;
          pMeshContainer->pMaterials = NULL;
      }
  
      if( pMeshContainer->pBoneOffsetMatrices )
      {
          delete[] pMeshContainer->pBoneOffsetMatrices;
          pMeshContainer->pBoneOffsetMatrices = NULL;
      }
  
      // release all the allocated textures
      if (pMeshContainer->ppTextures != NULL)
      {
          for (iMaterial = 0; iMaterial < pMeshContainer->NumMaterials; iMaterial++)
          {
              RELEASE( pMeshContainer->ppTextures[iMaterial] );
          }
          delete[] pMeshContainer->ppTextures;
          pMeshContainer->ppTextures = NULL;
      }
  
      if( pMeshContainer->ppBoneMatrixPtrs )
      {
          delete[] pMeshContainer->ppBoneMatrixPtrs;
          pMeshContainer->ppBoneMatrixPtrs = NULL;
      }
  
      RELEASE( pMeshContainer->pBoneCombinationBuf );
      RELEASE( pMeshContainer->MeshData.pMesh );
      RELEASE( pMeshContainer->pSkinInfo );
      RELEASE( pMeshContainer->pOrigMesh );
  
      if( pMeshContainer )
      {
          delete pMeshContainer;
          pMeshContainer = NULL;
      }
  
      return S_OK;
  }
  
  //-----------------------------------------------------------------------------
  // Name: CAllocateHierarchy::GenerateSkinnedMesh_()
  // Desc: 
  //-----------------------------------------------------------------------------
  HRESULT CAllocateHierarchy::GenerateSkinnedMesh_(D3DXMESHCONTAINER_DERIVED *pMeshContainer)
  {
      HRESULT hr = S_OK;
      
      if( !pMeshContainer )
      {
          return E_POINTER;
      }
  
      if (pMeshContainer->pSkinInfo == NULL)
          return hr;
  
      try
      {
          RELEASE( pMeshContainer->MeshData.pMesh );
          RELEASE( pMeshContainer->pBoneCombinationBuf );
  
          CHECK_HR(
          hr = pMeshContainer->pSkinInfo->ConvertToBlendedMesh
                                     (
                                         pMeshContainer->pOrigMesh,
                                         D3DXMESH_MANAGED|D3DXMESHOPT_VERTEXCACHE, 
                                         pMeshContainer->pAdjacency, 
                                         NULL, NULL, NULL, 
                                         &pMeshContainer->NumInfl,
                                         &pMeshContainer->NumAttributeGroups, 
                                         &pMeshContainer->pBoneCombinationBuf, 
                                         &pMeshContainer->MeshData.pMesh
                                     ),
          DbgMsg("CAllocateHierarchy::GenerateSkinnedMesh_: failed in ConvertToBlendedMesh, hr = 0x%08x", hr));
  
          LPD3DXBONECOMBINATION rgBoneCombinations  = reinterpret_cast<LPD3DXBONECOMBINATION>(
                              pMeshContainer->pBoneCombinationBuf->GetBufferPointer());
  
          // if there is both HW and SW, add the Software Processing flag
          if (pMeshContainer->iAttributeSW < pMeshContainer->NumAttributeGroups)
          {
              LPD3DXMESH pMeshTmp;
  
              CHECK_HR(
              hr = pMeshContainer->MeshData.pMesh->CloneMeshFVF(
                              D3DXMESH_SOFTWAREPROCESSING | pMeshContainer->MeshData.pMesh->GetOptions(), 
                              pMeshContainer->MeshData.pMesh->GetFVF(),
                              m_pDevice, 
                              &pMeshTmp),
              DbgMsg("CAllocateHierarchy::GenerateSkinnedMesh_: failed in CloneMeshFVF, hr = 0x%08x", hr));
  
              pMeshContainer->MeshData.pMesh->Release();
              pMeshContainer->MeshData.pMesh = pMeshTmp;
              pMeshTmp = NULL;
          }
      }// try
      catch( HRESULT hr1 )
      {
          hr = hr1;
      }
  
      return hr;
  }