C++ LPDIRECTXFILEDATA::GetType方法代码示例

HRESULT CXFrameNode::MergeFromXData(char* Filename, CXModel* Model, LPDIRECTXFILEDATA XObj)
{
	HRESULT res = S_OK;

	// get the type of the object
	const GUID* ObjectType;
	res = XObj->GetType(&ObjectType);
	if(FAILED(res))
	{
		Game->LOG(res, "Error getting object type");
		return res;
	}
	// load animation set
	else if(*ObjectType == TID_D3DRMAnimationSet )
	{
		return Model->LoadAnimationSet(Filename, XObj);
	}

	// load a single animation (shouldn't happen here)
	else if(*ObjectType == TID_D3DRMAnimation)
	{
		return Model->LoadAnimation(Filename, XObj);
	}

	// scan child frames
	else if(*ObjectType == TID_D3DRMFrame)
	{
		// Enumerate child objects.
		// Child object can be data, data reference or binary.
		// Use QueryInterface() to find what objecttype of object a child is.
		LPDIRECTXFILEDATA XChildData;
		LPDIRECTXFILEOBJECT XChildObj;
		res = E_FAIL;
		while(SUCCEEDED(XObj->GetNextObject(&XChildObj)))
		{
			// Query the child for it's FileData
			res = XChildObj->QueryInterface(IID_IDirectXFileData, (void**)&XChildData);
			if(SUCCEEDED(res))
			{
				// load the child's object
				res = MergeFromXData(Filename, Model, XChildData);
				RELEASE(XChildData);
			}
			RELEASE(XChildObj);
		}
		return res;
	}
	return S_OK; // unknown type, ignore
}

//-----------------------------------------------------------------------------
// Name:
// Desc:
//-----------------------------------------------------------------------------
HRESULT CD3DFile::LoadFrame( LPDIRECT3DDEVICE9 pd3dDevice,
                             LPDIRECTXFILEDATA pFileData,
                             CD3DFrame* pParentFrame )
{
    LPDIRECTXFILEDATA   pChildData = NULL;
    LPDIRECTXFILEOBJECT pChildObj = NULL;
    const GUID* pGUID;
    DWORD       cbSize;
    CD3DFrame*  pCurrentFrame;
    HRESULT     hr;

    // Get the type of the object
    if( FAILED( hr = pFileData->GetType( &pGUID ) ) )
        return hr;

    if( *pGUID == TID_D3DRMMesh )
    {
        hr = LoadMesh( pd3dDevice, pFileData, pParentFrame );
        if( FAILED(hr) )
            return hr;
    }
    if( *pGUID == TID_D3DRMFrameTransformMatrix )
    {
        D3DXMATRIX* pmatMatrix;
        hr = pFileData->GetData( NULL, &cbSize, (void**)&pmatMatrix );
        if( FAILED(hr) )
            return hr;

        // Update the parent's matrix with the new one
        pParentFrame->SetMatrix( pmatMatrix );
    }
    if( *pGUID == TID_D3DRMFrame )
    {
        // Get the frame name
        CHAR  strAnsiName[512] = "";
        TCHAR strName[512];
        DWORD dwNameLength = 512;
        if( FAILED( hr = pFileData->GetName( strAnsiName, &dwNameLength ) ) )
            return hr;
        DXUtil_ConvertAnsiStringToGenericCb( strName, strAnsiName, sizeof(strName) );

        // Create the frame
        pCurrentFrame = new CD3DFrame( strName );
        if( pCurrentFrame == NULL )
            return E_OUTOFMEMORY;

        pCurrentFrame->m_pNext = pParentFrame->m_pChild;
        pParentFrame->m_pChild = pCurrentFrame;

        // Enumerate child objects
        while( SUCCEEDED( pFileData->GetNextObject( &pChildObj ) ) )
        {
            // Query the child for its FileData
            hr = pChildObj->QueryInterface( IID_IDirectXFileData,
                                            (void**)&pChildData );
            if( SUCCEEDED(hr) )
            {
                hr = LoadFrame( pd3dDevice, pChildData, pCurrentFrame );
                pChildData->Release();
            }

            pChildObj->Release();

            if( FAILED(hr) )
                return hr;
        }
    }

    return S_OK;
}

HRESULT CXFrameNode::LoadFromXData(char* Filename, CXModel* Model, LPDIRECTXFILEDATA XObj)
{
	Game->MiniUpdate();

	HRESULT res = S_OK;

	// {9E415A43-7BA6-4a73-8743-B73D47E88476}
	GUID DXFILEOBJ_AnimTicksPerSecond = { 0x9e415a43, 0x7ba6, 0x4a73, { 0x87, 0x43, 0xb7, 0x3d, 0x47, 0xe8, 0x84, 0x76 } };

	// get the type of the object
	GUID ObjectType;
	res = XObj->GetType(&ObjectType);
	if(FAILED(res))
	{
		Game->LOG(res, "Error getting object type");
		return res;
	}

	// load a child mesh
	if(ObjectType == TID_D3DRMMesh)
	{
		CXMesh* Mesh = new CXMesh(Game);
		res = Mesh->LoadFromXData(Filename, XObj);
		if(SUCCEEDED(res))
		{
			m_Meshes.Add(Mesh);
			return S_OK;
		}
		else
		{
			SAFE_DELETE(Mesh);
			return res;
		}		
	}


	// load the transformation matrix
	else if(ObjectType == TID_D3DRMFrameTransformMatrix)
	{		
		D3DXMATRIX* mat;
		SIZE_T Size;

		res = XObj->Lock(&Size, (LPCVOID*)&mat);
		if(FAILED(res))
		{
			Game->LOG(res, "Error loading transformation matrix");
			return res;
		}
		else
		{
			m_TransformationMatrix = *mat;
			m_OriginalMatrix = *mat;
			XObj->Unlock();
			return S_OK;
		}
	}

	// load animation set
	else if(ObjectType == TID_D3DRMAnimationSet )
	{
		return Model->LoadAnimationSet(Filename, XObj);
	}

	// load a single animation (shouldn't happen here)
	else if(ObjectType == TID_D3DRMAnimation)
	{
		return Model->LoadAnimation(Filename, XObj);
	}

	// create a new child frame
	else if(ObjectType == TID_D3DRMFrame)
	{
		CXFrameNode* ChildFrame = new CXFrameNode(Game);

		// get the name of the child frame
		res = CXModel::LoadName(ChildFrame, XObj);
		if(FAILED(res))
		{
			Game->LOG(res, "Error loading frame name");
			SAFE_DELETE(ChildFrame);
			return res;
		}

		// Enumerate child objects.
		// Child object can be data, data reference or binary.
		// Use QueryInterface() to find what objecttype of object a child is.
		res = E_FAIL;

		SIZE_T NumChildren;
		XObj->GetChildren(&NumChildren);
		for(SIZE_T i=0; i<NumChildren; i++)
		{
			LPDIRECTXFILEDATA XChildData;
			res = XObj->GetChild(i, &XChildData);
			if(SUCCEEDED(res))
			{
				res = ChildFrame->LoadFromXData(Filename, Model, XChildData);
				RELEASE(XChildData);
			}
		}
//.........这里部分代码省略.........