sdkmesh.cpp

声音和图片的加载功能,不过运行起来有点卡

            }
            pd3dDevice->DrawIndexed( IndexCount, IndexStart, VertexStart );
        }
    }
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::RenderFrame( UINT iFrame,
                                bool bAdjacent,
                                ID3D10Device* pd3dDevice, 
                                ID3D10EffectTechnique* pTechnique, 
                                ID3D10EffectShaderResourceVariable* ptxDiffuse,
                                ID3D10EffectShaderResourceVariable* ptxNormal,
                                ID3D10EffectShaderResourceVariable* ptxSpecular,
                                ID3D10EffectVectorVariable* pvDiffuse, 
                                ID3D10EffectVectorVariable* pvSpecular )
{
    if( !m_pStaticMeshData || !m_pFrameArray )
        return;

    if( m_pFrameArray[iFrame].Mesh != INVALID_MESH )
    {
        RenderMesh( m_pFrameArray[iFrame].Mesh,
                   bAdjacent, 
                   pd3dDevice, 
                   pTechnique, 
                   ptxDiffuse,
                   ptxNormal,
                   ptxSpecular,
                   pvDiffuse, 
                   pvSpecular );
    }

    // Render our children
    if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME )
        RenderFrame( m_pFrameArray[iFrame].ChildFrame, bAdjacent, pd3dDevice, pTechnique, ptxDiffuse, ptxNormal, ptxSpecular, pvDiffuse, pvSpecular );

    // Render our siblings
    if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME )
        RenderFrame( m_pFrameArray[iFrame].SiblingFrame, bAdjacent, pd3dDevice, pTechnique, ptxDiffuse, ptxNormal, ptxSpecular, pvDiffuse, pvSpecular );
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::RenderMesh( UINT iMesh,
                               LPDIRECT3DDEVICE9 pd3dDevice,
                               LPD3DXEFFECT pEffect,
                               D3DXHANDLE hTechnique,
                               D3DXHANDLE htxDiffuse,
                               D3DXHANDLE htxNormal,
                               D3DXHANDLE htxSpecular )
{
    if( 0 < GetOutstandingBufferResources() )
        return;

    SDKMESH_MESH* pMesh = &m_pMeshArray[iMesh];

    // set vb streams
    for( UINT i=0; i<(UINT)pMesh->NumVertexBuffers; i++ )
    {
        pd3dDevice->SetStreamSource( i, 
                                     m_pVertexBufferArray[ pMesh->VertexBuffers[i] ].pVB9, 
                                     0, 
                                     (UINT)m_pVertexBufferArray[ pMesh->VertexBuffers[i] ].StrideBytes );
    }

    // Set our index buffer as well
    pd3dDevice->SetIndices( m_pIndexBufferArray[ pMesh->IndexBuffer ].pIB9 );

    // Render the scene with this technique 
    pEffect->SetTechnique( hTechnique );

    SDKMESH_SUBSET* pSubset = NULL;
    SDKMESH_MATERIAL* pMat = NULL;
    D3DPRIMITIVETYPE PrimType;
    UINT cPasses = 0;
    pEffect->Begin(&cPasses, 0);

    for( UINT p = 0; p < cPasses; ++p )
    {
        pEffect->BeginPass(p);

        for( UINT subset = 0; subset < pMesh->NumSubsets; subset++ )
        {
            pSubset = &m_pSubsetArray[ pMesh->pSubsets[subset] ];

            PrimType = GetPrimitiveType9( (SDKMESH_PRIMITIVE_TYPE)pSubset->PrimitiveType );

            if( INVALID_MATERIAL != pSubset->MaterialID && m_pMeshHeader->NumMaterials > 0 )
            {
                pMat = &m_pMaterialArray[ pSubset->MaterialID ];
                if( htxDiffuse && !IsErrorResource(pMat->pDiffuseTexture9) )
                    pEffect->SetTexture( htxDiffuse, pMat->pDiffuseTexture9 );
                if( htxNormal && !IsErrorResource(pMat->pNormalTexture9)  )
                    pEffect->SetTexture( htxNormal, pMat->pNormalTexture9 );
                if( htxSpecular && !IsErrorResource(pMat->pSpecularTexture9) )
                    pEffect->SetTexture( htxSpecular, pMat->pSpecularTexture9 );
            }

            pEffect->CommitChanges();

            UINT PrimCount = (UINT)pSubset->IndexCount;
            UINT IndexStart = (UINT)pSubset->IndexStart;
            UINT VertexStart = (UINT)pSubset->VertexStart;
            UINT VertexCount = (UINT)pSubset->VertexCount;
            if( D3DPT_TRIANGLELIST == PrimType )
                PrimCount /= 3;
            if( D3DPT_LINELIST == PrimType )
                PrimCount /= 2;
            if( D3DPT_TRIANGLESTRIP == PrimType )
                PrimCount = (PrimCount-3) + 1;
            if( D3DPT_LINESTRIP == PrimType )
                PrimCount -= 1;

            pd3dDevice->DrawIndexedPrimitive( PrimType, VertexStart, 0, VertexCount, IndexStart, PrimCount );
        }

        pEffect->EndPass();
    }

    pEffect->End();
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::RenderFrame( UINT iFrame,
                                LPDIRECT3DDEVICE9 pd3dDevice,
                                LPD3DXEFFECT pEffect,
                                D3DXHANDLE hTechnique,
                                D3DXHANDLE htxDiffuse,
                                D3DXHANDLE htxNormal,
                                D3DXHANDLE htxSpecular )
{
    if( !m_pStaticMeshData || !m_pFrameArray )
        return;

    if( m_pFrameArray[iFrame].Mesh != INVALID_MESH )
    {
        RenderMesh( m_pFrameArray[iFrame].Mesh,
                   pd3dDevice, 
                   pEffect,
                   hTechnique, 
                   htxDiffuse,
                   htxNormal,
                   htxSpecular );
    }

    // Render our children
    if( m_pFrameArray[iFrame].ChildFrame != INVALID_FRAME )
        RenderFrame( m_pFrameArray[iFrame].ChildFrame, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, htxSpecular );

    // Render our siblings
    if( m_pFrameArray[iFrame].SiblingFrame != INVALID_FRAME )
        RenderFrame( m_pFrameArray[iFrame].SiblingFrame, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, htxSpecular );
}


//--------------------------------------------------------------------------------------
CDXUTSDKMesh::CDXUTSDKMesh() :
m_NumOutstandingResources(0),
m_bLoading(false),
m_hFile(0),
m_hFileMappingObject(0),
m_pMeshHeader(NULL),
m_pStaticMeshData(NULL),
m_pHeapData(NULL),
m_pAdjacencyIndexBufferArray(NULL),
m_pAnimationData(NULL),
m_pBindPoseFrameMatrices(NULL),
m_pTransformedFrameMatrices(NULL),
m_pDev9(NULL),
m_pDev10(NULL)
{
}


//--------------------------------------------------------------------------------------
CDXUTSDKMesh::~CDXUTSDKMesh()
{
    Destroy();
}

//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::Create( ID3D10Device *pDev10, LPCTSTR szFileName, bool bOptimize, bool bCreateAdjacencyIndices, SDKMESH_CALLBACKS10* pLoaderCallbacks )
{
    return CreateFromFile( pDev10, NULL, szFileName, bOptimize, bCreateAdjacencyIndices, pLoaderCallbacks, NULL );
}

//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::Create( IDirect3DDevice9* pDev9, LPCTSTR szFileName, bool bOptimize, bool bCreateAdjacencyIndices, SDKMESH_CALLBACKS9* pLoaderCallbacks )
{
    return CreateFromFile( NULL, pDev9, szFileName, bOptimize, bCreateAdjacencyIndices, NULL, pLoaderCallbacks );
}

//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::Create( ID3D10Device *pDev10, BYTE* pData, UINT DataBytes, bool bOptimize, bool bCreateAdjacencyIndices, bool bCopyStatic, SDKMESH_CALLBACKS10* pLoaderCallbacks )
{
    return CreateFromMemory( pDev10, NULL, pData, DataBytes, bOptimize, bCreateAdjacencyIndices, bCopyStatic, pLoaderCallbacks, NULL );
}

//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::Create( IDirect3DDevice9* pDev9, BYTE* pData, UINT DataBytes, bool bOptimize, bool bCreateAdjacencyIndices, bool bCopyStatic, SDKMESH_CALLBACKS9* pLoaderCallbacks )
{
    return CreateFromMemory( NULL, pDev9, pData, DataBytes, bOptimize, bCreateAdjacencyIndices, bCopyStatic, NULL, pLoaderCallbacks );
}

//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::LoadAnimation( WCHAR* szFileName )
{
    HRESULT hr = E_FAIL;
    DWORD dwBytesRead = 0;
    LARGE_INTEGER liMove;
    WCHAR strPath[MAX_PATH];

    // Find the path for the file
    V_RETURN( DXUTFindDXSDKMediaFileCch( strPath, MAX_PATH, szFileName ) );

    // Open the file
    HANDLE hFile = CreateFile( strPath, FILE_READ_DATA, FILE_SHARE_READ, NULL, OPEN_EXISTING, FILE_FLAG_SEQUENTIAL_SCAN, NULL );
    if( INVALID_HANDLE_VALUE == hFile )
        return DXUTERR_MEDIANOTFOUND;

    /////////////////////////
    // Header
    SDKANIMATION_FILE_HEADER fileheader;
    if(!ReadFile( hFile, &fileheader, sizeof(SDKANIMATION_FILE_HEADER), &dwBytesRead, NULL ) )
        goto Error;

    //allocate
    m_pAnimationData = new BYTE[ (size_t)(sizeof(SDKANIMATION_FILE_HEADER) + fileheader.AnimationDataSize) ];
    if( !m_pAnimationData )
    {
        hr = E_OUTOFMEMORY;
        goto Error;
    }

    // read it all in
    liMove.QuadPart = 0;
    if( !SetFilePointerEx( hFile, liMove, NULL, FILE_BEGIN ) )
        goto Error;
    if(!ReadFile( hFile, m_pAnimationData, (DWORD)(sizeof(SDKANIMATION_FILE_HEADER) + fileheader.AnimationDataSize), &dwBytesRead, NULL ) )
        goto Error;

    // pointer fixup
    m_pAnimationHeader = (SDKANIMATION_FILE_HEADER*)m_pAnimationData;
    m_pAnimationFrameData = (SDKANIMATION_FRAME_DATA*)(m_pAnimationData + m_pAnimationHeader->AnimationDataOffset);

    UINT64 BaseOffset = sizeof(SDKANIMATION_FILE_HEADER);
    for( UINT i=0; i<m_pAnimationHeader->NumFrames; i++ )
    {
        m_pAnimationFrameData[i].pAnimationData = (SDKANIMATION_DATA*)(m_pAnimationData + m_pAnimationFrameData[i].DataOffset + BaseOffset);
        SDKMESH_FRAME* pFrame = FindFrame( m_pAnimationFrameData[i].FrameName );
        if( pFrame )
        {
            pFrame->AnimationDataIndex = i;
        }
    }

    hr = S_OK;
Error:
    CloseHandle( hFile );
    return hr;
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::Destroy()
{
    if( !CheckLoadDone() )
        return;

    if( m_pStaticMeshData )
    {
        if( m_pMaterialArray )
        {
            for( UINT64 m=0; m<m_pMeshHeader->NumMaterials; m++ )
            {
                if( m_pDev9 )
                {
                    if( !IsErrorResource( m_pMaterialArray[m].pDiffuseTexture9 ) )
                        SAFE_RELEASE( m_pMaterialArray[m].pDiffuseTexture9 );
                    if( !IsErrorResource( m_pMaterialArray[m].pNormalTexture9 ) )
                        SAFE_RELEASE( m_pMaterialArray[m].pNormalTexture9 );
                    if( !IsErrorResource( m_pMaterialArray[m].pSpecularTexture9 ) )
                        SAFE_RELEASE( m_pMaterialArray[m].pSpecularTexture9 );
                }
                else
                {
                    ID3D10Resource* pRes = NULL;
                    if( m_pMaterialArray[m].pDiffuseRV10 && !IsErrorResource( m_pMaterialArray[m].pDiffuseRV10 ) )
                    {
                        m_pMaterialArray[m].pDiffuseRV10->GetResource( &pRes );
                        SAFE_RELEASE( pRes );
                        SAFE_RELEASE( pRes );	// do this twice, because GetResource adds a ref

                        SAFE_RELEASE( m_pMaterialArray[m].pDiffuseRV10 );
                    }
                    if( m_pMaterialArray[m].pNormalRV10 && !IsErrorResource( m_pMaterialArray[m].pNormalRV10 )  )
                    {
                        m_pMaterialArray[m].pNormalRV10->GetResource( &pRes );
                        SAFE_RELEASE( pRes );
                        SAFE_RELEASE( pRes );	// do this twice, because GetResource adds a ref

                        SAFE_RELEASE( m_pMaterialArray[m].pNormalRV10 );
                    }
                    if( m_pMaterialArray[m].pSpecularRV10 && !IsErrorResource( m_pMaterialArray[m].pSpecularRV10 ) )
                    {
                        m_pMaterialArray[m].pSpecularRV10->GetResource( &pRes );
                        SAFE_RELEASE( pRes );
                        SAFE_RELEASE( pRes );	// do this twice, because GetResource adds a ref

                        SAFE_RELEASE( m_pMaterialArray[m].pSpecularRV10 );
                    }
                }
            }
        }

        for( UINT64 i=0; i<m_pMeshHeader->NumVertexBuffers; i++ )
        {
            if( !IsErrorResource( m_pVertexBufferArray[i].pVB9 ) )
                SAFE_RELEASE( m_pVertexBufferArray[i].pVB9 );
        }

        for( UINT64 i=0; i<m_pMeshHeader->NumIndexBuffers; i++ )
        {
            if( !IsErrorResource( m_pIndexBufferArray[i].pIB9 ) )
                SAFE_RELEASE( m_pIndexBufferArray[i].pIB9 );
        }
    }

    if( m_pAdjacencyIndexBufferArray )
    {
        for( UINT64 i=0; i<m_pMeshHeader->NumIndexBuffers; i++ )
        {
            SAFE_RELEASE( m_pAdjacencyIndexBufferArray[i].pIB10 );
        }
    }
    SAFE_DELETE_ARRAY( m_pAdjacencyIndexBufferArray );

    SAFE_DELETE_ARRAY( m_pHeapData );
    m_pStaticMeshData = NULL;
    SAFE_DELETE_ARRAY( m_pAnimationData );
    SAFE_DELETE_ARRAY( m_pBindPoseFrameMatrices );
    SAFE_DELETE_ARRAY( m_pTransformedFrameMatrices );

    m_pMeshHeader = NULL;
    m_pVertexBufferArray = NULL;