Re: C2259 : cannot instantiate abstract class

"John Carson" <jcarson_n_o_sp_am_@netspace.net.au> ???g???l???s?D:%23NaSbY9MHHA.4384@TK2MSFTNGP03.phx.gbl...


Ok.. Let's start it from there
========================================================
DECLARE_INTERFACE(ID3DXAllocateHierarchy)
{
   // ID3DXAllocateHierarchy

//------------------------------------------------------------------------
// CreateFrame:
// ------------
// Requests allocation of a frame object.
//
// Parameters:
// Name
// Name of the frame to be created
// ppNewFrame
// Returns the created frame object
//
//------------------------------------------------------------------------
   STDMETHOD(CreateFrame)(THIS_ LPCSTR Name,
                           LPD3DXFRAME *ppNewFrame) PURE;

//------------------------------------------------------------------------
// CreateMeshContainer:
// --------------------
// Requests allocation of a mesh container object.
//
// Parameters:
// Name
// Name of the mesh
// pMesh
// Pointer to the mesh object if basic polygon data found
// pPMesh
// Pointer to the progressive mesh object if progressive mesh data found
// pPatchMesh
// Pointer to the patch mesh object if patch data found
// pMaterials
// Array of materials used in the mesh
// pEffectInstances
// Array of effect instances used in the mesh
// NumMaterials
// Num elements in the pMaterials array
// pAdjacency
// Adjacency array for the mesh
// pSkinInfo
// Pointer to the skininfo object if the mesh is skinned
// pBoneNames
// Array of names, one for each bone in the skinned mesh.
// The numberof bones can be found from the pSkinMesh object
// pBoneOffsetMatrices
// Array of matrices, one for each bone in the skinned mesh.
//
//------------------------------------------------------------------------
   STDMETHOD(CreateMeshContainer)(THIS_
       LPCSTR Name,
       CONST D3DXMESHDATA *pMeshData,
       CONST D3DXMATERIAL *pMaterials,
       CONST D3DXEFFECTINSTANCE *pEffectInstances,
       DWORD NumMaterials,
       CONST DWORD *pAdjacency,
       LPD3DXSKININFO pSkinInfo,
       LPD3DXMESHCONTAINER *ppNewMeshContainer) PURE;

//------------------------------------------------------------------------
// DestroyFrame:
// -------------
// Requests de-allocation of a frame object.
//
// Parameters:
// pFrameToFree
// Pointer to the frame to be de-allocated
//
//------------------------------------------------------------------------
   STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree) PURE;

//------------------------------------------------------------------------
// DestroyMeshContainer:
// ---------------------
// Requests de-allocation of a mesh container object.
//
// Parameters:
// pMeshContainerToFree
// Pointer to the mesh container object to be de-allocated
//
//------------------------------------------------------------------------
   STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER
pMeshContainerToFree) PURE;
};

======================================================
Derived class: hope it won't be too overkilled :)

class CAllocateHierarchy : public ID3DXAllocateHierarchy
{
public:

   // ID3DXInterpolator
   STDMETHOD(CreateFrame)(THIS_ LPCSTR Name,
                           LPD3DXFRAME *ppNewFrame)
   {
       HRESULT hr = S_OK;
       SFrame *pFrame;

       *ppNewFrame = NULL;

       pFrame = new SFrame;
       if (pFrame == NULL)
       {
           hr = E_OUTOFMEMORY;
           goto e_Exit;
       }

       hr = AllocateName(Name, &pFrame->szName);
       if (FAILED(hr))
           goto e_Exit;

       *ppNewFrame = (LPD3DXFRAME)pFrame;
       pFrame = NULL;
e_Exit:
       delete pFrame;
       return hr;
   }

   STDMETHOD(CreateMeshContainer)(THIS_ LPCSTR Name, LPD3DXMESHDATA
pMeshData,
                           LPD3DXMATERIAL pMaterials, LPD3DXEFFECTINSTANCE
pEffects, DWORD NumMaterials,
                           DWORD *pAdjacency, LPD3DXSKININFO pSkinInfo,
                           LPD3DXMESHCONTAINER *ppNewMeshContainer)
   {
       HRESULT hr;
       SMeshContainer *pMeshContainer = NULL;
       UINT iBone, cBones;
       UINT NumFaces;
       UINT iMaterial;
       LPDIRECT3DDEVICE9 pd3dDevice = NULL;
       LPDIRECT3DTEXTURE9 ptex;
       LPD3DXEFFECT pEffect;
       D3DVERTEXELEMENT9 pDecl[MAX_FVF_DECL_SIZE];
       CD3DXCrackDecl1 cd;
       DWORD dwSkinningSupport;
       LPD3DXBUFFER pbufErrors;
       D3DXVECTOR3 vMeshCenter;
       FLOAT fMeshRadius;
       BOOL bUsesTangents = FALSE;

       LPD3DXMESH pMesh = NULL;
       LPD3DXPMESH pPMesh = NULL;
       LPD3DXPATCHMESH pPatchMesh = NULL;

       if (pMeshData->Type == D3DXMESHTYPE_PATCHMESH)
           pPatchMesh = pMeshData->pPatchMesh;
       else if (pMeshData->Type == D3DXMESHTYPE_PMESH)
           pPMesh = pMeshData->pPMesh;
       else
           pMesh = pMeshData->pMesh;

       *ppNewMeshContainer = NULL;

       pMeshContainer = new SMeshContainer;
       if (pMeshContainer == NULL)
       {
           hr = E_OUTOFMEMORY;
           goto e_Exit;
       }

       pMeshContainer->m_Method = g_pData->m_method;
       pMeshContainer->m_iPaletteSize = g_pData->m_iPaletteSize;

       hr = AllocateName(Name, &pMeshContainer->Name);
       if (FAILED(hr))
           goto e_Exit;

       // if a patch mesh is found, enable tesselate mode for this node
and then generate a mesh via tesselation
       if (pPatchMesh != NULL)
       {
           pPatchMesh->GetDevice(&pd3dDevice);

           pMeshContainer->pPatchMesh = pPatchMesh;
           pPatchMesh->AddRef();

           hr = g_pData->Tesselate(pMeshContainer, FALSE);
           if(FAILED(hr))
               goto e_Exit;

           pPatchMesh->GetDeclaration(pDecl);

           pMeshContainer->bTesselateMode = TRUE;
       }
       // if a pmesh is found, setup this node to enable pmeshes and
allocate an adjacency array large enough for the max LOD
       else if (pPMesh != NULL)
       {
           pPMesh->GetDevice(&pd3dDevice);

           pMeshContainer->bPMMeshMode = true;

           pMeshContainer->m_cNumVertices = pPMesh->GetNumVertices();
           pMeshContainer->m_cMaxVerticesSoft = pPMesh->GetMaxVertices();
           pMeshContainer->m_cMinVerticesSoft = pPMesh->GetMinVertices();

           pMeshContainer->pPMMesh = pPMesh;
           pMeshContainer->pPMMesh->AddRef();

           NumFaces = pMeshContainer->pPMMesh->GetMaxFaces();

           pMeshContainer->rgdwAdjacency = new DWORD[NumFaces*3];
           if (pMeshContainer->rgdwAdjacency == NULL)
           {
               hr = E_OUTOFMEMORY;
               goto e_Exit;
           }

           // get the adjacency from the pmesh rather than the input

pMeshContainer->pPMMesh->GetAdjacency(pMeshContainer->rgdwAdjacency);

           pMeshContainer->pPMMesh->GetDeclaration(pDecl);
       }
       // standard mesh found, allocate an adjacency buffer of the same
size
       else
       {

           pMesh->GetDevice(&pd3dDevice);

           pMeshContainer->pMesh = pMesh;
           pMeshContainer->pMesh->AddRef();

           NumFaces = pMeshContainer->pMesh->GetNumFaces();

           pMeshContainer->rgdwAdjacency = new DWORD[NumFaces*3];
           if (pMeshContainer->rgdwAdjacency == NULL)
           {
               hr = E_OUTOFMEMORY;
               goto e_Exit;
           }

           memcpy(pMeshContainer->rgdwAdjacency, pAdjacency, sizeof(DWORD)
* NumFaces*3);

           pMeshContainer->pMesh->GetDeclaration(pDecl);
       }

       //.now that we have data for the vertex layout, create a crack decl
       cd.SetDeclaration(pDecl);

       // if no materials are found, then generate a "default" material of
gray
       if ((pMaterials == NULL) || (NumMaterials == 0))
       {
           pMeshContainer->NumMaterials = 1;
           pMeshContainer->m_cAttributeGroups = 1;
           pMeshContainer->m_rgpfxAttributes = new
LPD3DXEFFECT[pMeshContainer->NumMaterials];
           pMeshContainer->m_rgEffectInfo = new
SEffectInfo[pMeshContainer->NumMaterials];
           pMeshContainer->rgMaterials = new
D3DXMATERIAL[pMeshContainer->NumMaterials];
           if ((pMeshContainer->rgMaterials == NULL) ||
(pMeshContainer->m_rgEffectInfo == NULL) ||
(pMeshContainer->m_rgpfxAttributes == NULL))
           {
               pMeshContainer->NumMaterials = 0;
               hr = E_OUTOFMEMORY;
               goto e_Exit;
           }

           memset(pMeshContainer->rgMaterials, 0, sizeof(D3DXMATERIAL) *
pMeshContainer->NumMaterials);
           memset(pMeshContainer->m_rgpfxAttributes, 0,
sizeof(LPD3DXEFFECT) * pMeshContainer->NumMaterials);

           D3DMATERIAL9 mat;
           memset(&mat, 0, sizeof(D3DMATERIAL9));
           mat.Diffuse.r = 0.5f;
           mat.Diffuse.g = 0.5f;
           mat.Diffuse.b = 0.5f;
           mat.Specular = mat.Diffuse;

           pMeshContainer->rgMaterials[0].MatD3D = mat;
           pMeshContainer->rgMaterials[0].pTextureFilename = NULL;

           D3DXEFFECTINSTANCE EffectInstance;

           memset(&EffectInstance, 0, sizeof(D3DXEFFECTINSTANCE));

           // create effect instance will create a "default" effect when
pEffectFilename is NULL
           hr = D3DXCreateEffectInstance(&EffectInstance, pd3dDevice,
&pMeshContainer->m_rgpfxAttributes[0], NULL);
           if (FAILED(hr))
               goto e_Exit;

           //hr = GenerateEffectInfo(pMeshContainer->m_rgpfxAttributes[0],
&pMeshContainer->m_rgEffectInfo[0]);
           //if (FAILED(hr))
               //goto e_Exit;

           // set our "default" material colors
           pMeshContainer->m_rgpfxAttributes[0]->SetVector("Ambient",
(LPD3DXVECTOR4)&mat.Ambient);
           pMeshContainer->m_rgpfxAttributes[0]->SetVector("Diffuse",
(LPD3DXVECTOR4)&mat.Diffuse);
           pMeshContainer->m_rgpfxAttributes[0]->SetVector("Specular",
(LPD3DXVECTOR4)&mat.Specular);
       }
       // materials found, so save them off
       else
       {
           pMeshContainer->m_rgpfxAttributes = new
LPD3DXEFFECT[NumMaterials];
           pMeshContainer->m_rgEffectInfo = new SEffectInfo[NumMaterials];
           pMeshContainer->rgMaterials = new D3DXMATERIAL[NumMaterials];
           pMeshContainer->pEffects = new
D3DXEFFECTINSTANCE[NumMaterials];
           pMeshContainer->NumMaterials = NumMaterials;
           pMeshContainer->m_cAttributeGroups = NumMaterials;
           if ((pMeshContainer->rgMaterials == NULL) ||
(pMeshContainer->m_rgEffectInfo == NULL) ||
(pMeshContainer->m_rgpfxAttributes == NULL))
           {
               pMeshContainer->NumMaterials = 0;
               hr = E_OUTOFMEMORY;
               goto e_Exit;
           }

           memset(pMeshContainer->rgMaterials, 0, sizeof(D3DXMATERIAL) *
NumMaterials);
           memset(pMeshContainer->m_rgpfxAttributes, 0,
sizeof(LPD3DXEFFECT) * NumMaterials);
           memset(pMeshContainer->pEffects, 0, sizeof(D3DXEFFECTINSTANCE)
* NumMaterials);

           for (iMaterial = 0; iMaterial < NumMaterials; iMaterial++)
           {
               hr = CopyEffectInstance(&pEffects[iMaterial],
&pMeshContainer->pEffects[iMaterial]);
               if (FAILED(hr))
                   goto e_Exit;

               pMeshContainer->rgMaterials[iMaterial].MatD3D =
pMaterials[iMaterial].MatD3D;

               ptex = NULL;
               if (pMaterials[iMaterial].pTextureFilename != NULL)
               {
                   DWORD cchFilename =
strlen(pMaterials[iMaterial].pTextureFilename) + 1;
                   pMeshContainer->rgMaterials[iMaterial].pTextureFilename
= new char[cchFilename];
                   if
(pMeshContainer->rgMaterials[iMaterial].pTextureFilename == NULL)
                   {
                       hr = E_OUTOFMEMORY;
                       goto e_Exit;
                   }

memcpy(pMeshContainer->rgMaterials[iMaterial].pTextureFilename,
                                   pMaterials[iMaterial].pTextureFilename,
sizeof(char) * cchFilename);
               }

               hr = D3DXCreateEffectInstance(&pEffects[iMaterial],
pd3dDevice, &pMeshContainer->m_rgpfxAttributes[iMaterial], &pbufErrors);

               if (pbufErrors)
               {
                   MessageBox(NULL, (LPSTR)pbufErrors->GetBufferPointer(),
"Effect file errors", MB_OK);
                   GXRELEASE(pbufErrors);
               }

               if (FAILED(hr))
                   goto e_Exit;

//pMeshContainer->m_rgpfxAttributes[iMaterial]->SetTechnique((LPCSTR)1);

               //hr =
GenerateEffectInfo(pMeshContainer->m_rgpfxAttributes[iMaterial],
&pMeshContainer->m_rgEffectInfo[iMaterial]);
               //if (FAILED(hr))
                 // goto e_Exit;
           }
       }

       // if skinning info is found, then we need to setup all info for
skinning this mesh container
       if (pSkinInfo != NULL)
       {
           pMeshContainer->pSkinInfo = pSkinInfo;
           pSkinInfo->AddRef();
           pMeshContainer->m_pOrigMesh = pMesh;
           pMesh->AddRef();

           cBones = pSkinInfo->GetNumBones();

           pMeshContainer->pBoneOffsetMatrices = new D3DXMATRIX[cBones];
           pMeshContainer->m_pBoneMatrix = new D3DXMATRIX*[cBones];
           if ((pMeshContainer->m_pBoneMatrix == NULL) ||
(pMeshContainer->pBoneOffsetMatrices == NULL))
           {
               hr = E_OUTOFMEMORY;
               goto e_Exit;
           }

           for (iBone = 0; iBone < cBones; iBone++)
           {
               pMeshContainer->pBoneOffsetMatrices[iBone] =
*(pSkinInfo->GetBoneOffsetMatrix(iBone));
           }

           hr = GenerateMesh(pMeshContainer);
           if (FAILED(hr))
               goto e_Exit;

           dwSkinningSupport = D3DXST_3WEIGHT;
       }
       else // non-skinned case, unskinned required
       {
           dwSkinningSupport = D3DXST_UNSKINNED;
       }

       pd3dDevice->SetSoftwareVertexProcessing(TRUE);
       pMeshContainer->m_dwSkinningType = dwSkinningSupport;

       pd3dDevice->SetFVF(D3DFVF_XYZ);

       // now that the skinning mode has been selected, select the first
technique to match it and validate
       for (iMaterial = 0; iMaterial < pMeshContainer->NumMaterials;
iMaterial++)
       {
           hr =
SelectTechnique(pMeshContainer->m_rgpfxAttributes[iMaterial],
dwSkinningSupport);
           if (FAILED(hr))
           {
               DPF(0, "CreateMeshContainer: No technique found that will
validate");
               goto e_Exit;
           }

           hr =
GenerateEffectInfo(pMeshContainer->m_rgpfxAttributes[iMaterial],
&pMeshContainer->m_rgEffectInfo[iMaterial]);
           if (FAILED(hr))
               goto e_Exit;

           D3DXTECHNIQUE_DESC TechniqueDesc;
           D3DXPASS_DESC PassDesc;
           D3DXHANDLE hPass;
           D3DXHANDLE hTechnique;
           hTechnique =
pMeshContainer->m_rgpfxAttributes[iMaterial]->GetCurrentTechnique();

pMeshContainer->m_rgpfxAttributes[iMaterial]->GetTechniqueDesc(hTechnique,
&TechniqueDesc);
           for( UINT iPass = 0; iPass < TechniqueDesc.Passes; iPass++ )
           {
               hPass =
pMeshContainer->m_rgpfxAttributes[iMaterial]->GetPass( hTechnique,
iPass );

pMeshContainer->m_rgpfxAttributes[iMaterial]->GetPassDesc( hPass,
&PassDesc );
  // for( UINT iSem = 0; iSem < PassDesc.Annotations; iSem++ )
             // {
               // if( PassDesc.VSSemantics[iSem].Usage ==
D3DDECLUSAGE_TANGENT )
                 // {
                   // bUsesTangents = TRUE;
                     // break;
                  // }
              // }
           }
       }

       pd3dDevice->SetSoftwareVertexProcessing(FALSE);

       // handle the case where there is a mesh without normals
       if (pMeshContainer->pMesh != NULL)
       {
           /* if no normals in the mesh, then clone the mesh to add the
normals and then compute them */
           if (cd.GetSemanticElement(D3DDECLUSAGE_NORMAL, 0) == NULL)
           {
               LPD3DXMESH pMeshTemp = pMeshContainer->pMesh;

               AddNormal(cd, pDecl);

               pMeshContainer->pMesh = NULL;

               // clone in the space for the new normal
               hr = pMeshTemp->CloneMesh(pMeshTemp->GetOptions(), pDecl,
pd3dDevice, &pMeshContainer->pMesh);

               GXRELEASE(pMeshTemp);

               if (FAILED(hr))
                   goto e_Exit;

               hr = D3DXComputeNormals(pMeshContainer->pMesh, NULL);
               if (FAILED(hr))
                   goto e_Exit;

           }

           if (bUsesTangents && (NULL ==
cd.GetSemanticElement(D3DDECLUSAGE_TANGENT, 0)))
           {
               LPD3DXMESH pMeshTemp = pMeshContainer->pMesh;

               AddTangent(cd, pDecl);

               pMeshContainer->pMesh = NULL;

               // clone in the space for the new normal
               hr = pMeshTemp->CloneMesh(pMeshTemp->GetOptions(), pDecl,
pd3dDevice, &pMeshContainer->pMesh);

               GXRELEASE(pMeshTemp);

               if (FAILED(hr))
                   goto e_Exit;

               hr = D3DXComputeTangent( pMeshContainer->pMesh, 0, 0,
D3DX_DEFAULT, TRUE, NULL );
               if (FAILED(hr))
                   goto e_Exit;
           }

           // down cast to the base mesh type (could also QI for it)
           GXRELEASE(pMeshContainer->ptmDrawMesh);
           pMeshContainer->ptmDrawMesh = pMeshContainer->pMesh;
           pMeshContainer->ptmDrawMesh->AddRef();

       }
       // handle the case where there is a pmesh without normals
       else if (pMeshContainer->pPMMesh != NULL)
       {
           /* if no normals in the mesh, then clone the mesh to add the
normals and then compute them */
           if (cd.GetSemanticElement(D3DDECLUSAGE_NORMAL, 0) == NULL)
           {
               LPD3DXPMESH pPMeshTemp = pMeshContainer->pPMMesh;
               pMeshContainer->pPMMesh = NULL;

               AddNormal(cd, pDecl);

               hr = pPMeshTemp->ClonePMesh(pPMeshTemp->GetOptions(),
pDecl, pd3dDevice, &pMeshContainer->pPMMesh);

               GXRELEASE(pPMeshTemp);

               if (FAILED(hr))
                   goto e_Exit;

               hr = D3DXComputeNormals(pMeshContainer->pPMMesh, NULL);
               if (FAILED(hr))
                   goto e_Exit;

           }

           // need compute tangent to take a base mesh
           if (bUsesTangents && (NULL ==
cd.GetSemanticElement(D3DDECLUSAGE_TANGENT, 0)))
           {
               LPD3DXMESH pMeshTemp;
               LPD3DXPMESH pPMeshTemp = pMeshContainer->pPMMesh;
               pMeshContainer->pPMMesh = NULL;

               AddTangent(cd, pDecl);

               hr = pPMeshTemp->ClonePMesh(pPMeshTemp->GetOptions(),
pDecl, pd3dDevice, &pMeshContainer->pPMMesh);

               GXRELEASE(pPMeshTemp);

               if (FAILED(hr))
                   goto e_Exit;

            // normal mesh required for compute tangent, so clone one that
uses the same VB and do the work there

               // set to Max LOD so that all vertices will be touched
               pMeshContainer->pPMMesh->SetNumVertices(0xffffffff);

               // clone the mesh NOTE: SHARING the VB
               hr =
pMeshContainer->pPMMesh->CloneMesh(pMeshContainer->pPMMesh->GetOptions() |
D3DXMESH_VB_SHARE, NULL, pd3dDevice, &pMeshTemp);
               if (FAILED(hr))
                   goto e_Exit;

               // compute the tangents on the mesh with the shared VB
               hr = D3DXComputeTangent( pMeshTemp, 0, 0, D3DX_DEFAULT,
TRUE, NULL );
               GXRELEASE (pMeshTemp);

               if (FAILED(hr))
                   goto e_Exit;
           }

           // down cast to the base mesh type (could also QI for it)
           GXRELEASE(pMeshContainer->ptmDrawMesh);
           pMeshContainer->ptmDrawMesh = pMeshContainer->pPMMesh;
           pMeshContainer->ptmDrawMesh->AddRef();
       }

       // setup attribute table
       pMeshContainer->ptmDrawMesh->GetAttributeTable(NULL,
&pMeshContainer->m_caeAttributeTable);

       // The load function will attribute sort the mesh, just make sure
that there is one
       GXASSERT(pMeshContainer->m_caeAttributeTable > 0);

       // allocate an attribute table for convenience purposes
       delete []pMeshContainer->m_rgaeAttributeTable;
       pMeshContainer->m_rgaeAttributeTable = new
D3DXATTRIBUTERANGE[pMeshContainer->m_caeAttributeTable];
       if (pMeshContainer->m_rgaeAttributeTable == NULL)
       {
           hr = E_OUTOFMEMORY;
           goto e_Exit;
       }

pMeshContainer->ptmDrawMesh->GetAttributeTable(pMeshContainer->m_rgaeAttributeTable,
&pMeshContainer->m_caeAttributeTable);

       hr = CalculateBoundingSphereMC(pMeshContainer, &vMeshCenter,
&fMeshRadius);
       if (FAILED(hr))
           goto e_Exit;

       // set the mesh radius/center into the effect
       for (iMaterial = 0; iMaterial < pMeshContainer->NumMaterials;
iMaterial++)
       {
           SetEffectMeshInfo(pMeshContainer->m_rgpfxAttributes[iMaterial],
&vMeshCenter, fMeshRadius);
       }

       *ppNewMeshContainer = (LPD3DXMESHCONTAINER)pMeshContainer;
       pMeshContainer = NULL;
e_Exit:
       GXRELEASE(pd3dDevice);

       // call Destroy function to properly clean up the memory allocated
       if (pMeshContainer != NULL)
       {
           DestroyMeshContainer((LPD3DXMESHCONTAINER)pMeshContainer);
       }

       return hr;
   }

   STDMETHOD(DestroyFrame)(THIS_ LPD3DXFRAME pFrameToFree)
   {
       SFrame *pFrame = (SFrame*)pFrameToFree;

       pFrame->pframeSibling = NULL;
       pFrame->pframeFirstChild = NULL;
       pFrame->pmcMesh = NULL;
       delete pFrame;
       return S_OK;
   }

   STDMETHOD(DestroyMeshContainer)(THIS_ LPD3DXMESHCONTAINER
pMeshContainerBase)
   {
       SMeshContainer *pMeshContainer =
(SMeshContainer*)pMeshContainerBase;

       // DON"T traverse the list of mesh containers to free them in the
destructor
       pMeshContainer->pNextMeshContainer = NULL;
       delete pMeshContainer;

       return S_OK;
   }
};

HRESULT
InitViews
   (
   SFrame *pframe,
   SDrawElement *pde
   )
{
   HRESULT hr = S_OK;
   SMeshContainer *pmcCur = pframe->pmcMesh;
   SFrame *pframeCur;

   while (pmcCur != NULL)
   {
       hr = pmcCur->UpdateViews(pde);
       if (FAILED(hr))
           goto e_Exit;

       pmcCur = (SMeshContainer*)pmcCur->pNextMeshContainer;
   }

   pframeCur = pframe->pframeFirstChild;
   while (pframeCur != NULL)
   {
       hr = InitViews(pframeCur, pde);
       if (FAILED(hr))
           goto e_Exit;

       pframeCur = pframeCur->pframeSibling;
   }

e_Exit:
   return hr;
}