sdkmesh.cpp

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

    m_pIndexBufferArray = NULL;
    m_pMeshArray = NULL;
    m_pSubsetArray = NULL;
    m_pFrameArray = NULL;
    m_pMaterialArray = NULL;

    m_pAnimationHeader = NULL;
    m_pAnimationFrameData = NULL;

}

//--------------------------------------------------------------------------------------
// transform the bind pose
//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::TransformBindPose( D3DXMATRIX* pWorld )
{
    TransformBindPoseFrame( 0, pWorld );
}

//--------------------------------------------------------------------------------------
// transform the mesh frames according to the animation for time fTime
//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::TransformMesh( D3DXMATRIX* pWorld, double fTime )
{
    if( !m_pAnimationHeader )
        return;

    if( FTT_RELATIVE == m_pAnimationHeader->FrameTransformType )
    {
        TransformFrame( 0, pWorld, fTime );

        // For each frame, move the transform to the bind pose, then
        // move it to the final position
        D3DXMATRIX mInvBindPose;
        D3DXMATRIX mFinal;
        for( UINT i=0; i<m_pMeshHeader->NumFrames; i++ )
        {
            D3DXMatrixInverse( &mInvBindPose, NULL, &m_pBindPoseFrameMatrices[i] );
            mFinal = mInvBindPose * m_pTransformedFrameMatrices[i];
            m_pTransformedFrameMatrices[i] = mFinal;
        }
    }
    else if( FTT_ABSOLUTE == m_pAnimationHeader->FrameTransformType )
    {
        for( UINT i=0; i<m_pAnimationHeader->NumFrames; i++ )
            TransformFrameAbsolute( i, fTime );
    }
}

//--------------------------------------------------------------------------------------
// Generate an adjacency index buffer for each mesh
//--------------------------------------------------------------------------------------
HRESULT CDXUTSDKMesh::CreateAdjacencyIndices( ID3D10Device *pd3dDevice, float fEpsilon, BYTE* pBufferData )
{
    HRESULT hr = S_OK;
    UINT IBIndex = 0;
    UINT VBIndex = 0;

    m_pAdjacencyIndexBufferArray = new SDKMESH_INDEX_BUFFER_HEADER[ m_pMeshHeader->NumIndexBuffers ];
    if( !m_pAdjacencyIndexBufferArray )
        return E_OUTOFMEMORY;

    for( UINT i=0; i<m_pMeshHeader->NumMeshes; i++ )
    {
        VBIndex = m_pMeshArray[i].VertexBuffers[0];
        IBIndex = m_pMeshArray[i].IndexBuffer;

        BYTE* pVertices = (BYTE*)( pBufferData + m_pVertexBufferArray[VBIndex].DataOffset );
        BYTE* pIndices = (BYTE*)( pBufferData + m_pIndexBufferArray[IBIndex].DataOffset );

        UINT stride = (UINT)m_pVertexBufferArray[VBIndex].StrideBytes;

        D3D10_INPUT_ELEMENT_DESC layout[2] =
        {
            { "POSITION", 0, DXGI_FORMAT_R32G32B32_FLOAT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
            { "END", 0, DXGI_FORMAT_R8_UINT, 0, 0, D3D10_INPUT_PER_VERTEX_DATA, 0 },
        };

        layout[1].AlignedByteOffset = stride - 1;

        // create the mesh 
        UINT NumVertices = (UINT)GetNumVertices( i, 0 );
        UINT NumIndices = (UINT)GetNumIndices( i );
        UINT Options = 0;
        ID3DX10Mesh* pMesh = NULL;

        if( DXGI_FORMAT_R32_UINT == GetIBFormat10(i) )
            Options |= D3DX10_MESH_32_BIT;
        V_RETURN( D3DX10CreateMesh( pd3dDevice,
                                    layout, 
                                    2,
                                    layout[0].SemanticName,
                                    NumVertices,
                                    NumIndices/3,
                                    Options, 
                                    &pMesh ) );

        //set the VB
        pMesh->SetVertexData( 0, (void*)pVertices );

        //set the IB
        pMesh->SetIndexData( (void*)pIndices, NumIndices );

        //generate adjacency
        pMesh->GenerateAdjacencyAndPointReps( fEpsilon );

        //generate adjacency indices
        pMesh->GenerateGSAdjacency();

        //get the adjacency data out of the mesh
        ID3DX10MeshBuffer* pIndexBuffer = NULL;
        BYTE* pAdjIndices = NULL;
        SIZE_T Size = 0;
        V_RETURN( pMesh->GetIndexBuffer( &pIndexBuffer ) );
        V_RETURN( pIndexBuffer->Map( (void**)&pAdjIndices, &Size ) );
        
        //Copy info about the original IB with a few modifications
        m_pAdjacencyIndexBufferArray[IBIndex] = m_pIndexBufferArray[IBIndex];
        m_pAdjacencyIndexBufferArray[IBIndex].SizeBytes *= 2;

        //create a new adjacency IB
        D3D10_BUFFER_DESC bufferDesc;
        bufferDesc.ByteWidth = (UINT)(Size);
        bufferDesc.Usage = D3D10_USAGE_IMMUTABLE;
        bufferDesc.BindFlags = D3D10_BIND_INDEX_BUFFER;
        bufferDesc.CPUAccessFlags = 0;
        bufferDesc.MiscFlags = 0;

        D3D10_SUBRESOURCE_DATA InitData;
        InitData.pSysMem = pAdjIndices;
        V_RETURN( pd3dDevice->CreateBuffer( &bufferDesc, &InitData, &m_pAdjacencyIndexBufferArray[IBIndex].pIB10 ) );

        //cleanup
        pIndexBuffer->Unmap();
        SAFE_RELEASE( pIndexBuffer );

        //release the ID3DX10Mesh
        SAFE_RELEASE( pMesh );
    }

    return hr;
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::Render(  ID3D10Device* pd3dDevice, 
                            ID3D10EffectTechnique* pTechnique, 
                            ID3D10EffectShaderResourceVariable* ptxDiffuse,
                            ID3D10EffectShaderResourceVariable* ptxNormal,
                            ID3D10EffectShaderResourceVariable* ptxSpecular,
                            ID3D10EffectVectorVariable* pvDiffuse, 
                            ID3D10EffectVectorVariable* pvSpecular )
{
    RenderFrame( 0, false, pd3dDevice, pTechnique, ptxDiffuse, ptxNormal, ptxSpecular, pvDiffuse, pvSpecular );
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::RenderAdjacent(  ID3D10Device* pd3dDevice, 
                                    ID3D10EffectTechnique* pTechnique, 
                                    ID3D10EffectShaderResourceVariable* ptxDiffuse,
                                    ID3D10EffectShaderResourceVariable* ptxNormal,
                                    ID3D10EffectShaderResourceVariable* ptxSpecular,
                                    ID3D10EffectVectorVariable* pvDiffuse, 
                                    ID3D10EffectVectorVariable* pvSpecular )
{
    RenderFrame( 0, true, pd3dDevice, pTechnique, ptxDiffuse, ptxNormal, ptxSpecular, pvDiffuse, pvSpecular );
}

//--------------------------------------------------------------------------------------
void CDXUTSDKMesh::Render(	LPDIRECT3DDEVICE9 pd3dDevice,
                            LPD3DXEFFECT pEffect,
                            D3DXHANDLE hTechnique,
                            D3DXHANDLE htxDiffuse,
                            D3DXHANDLE htxNormal,
                            D3DXHANDLE htxSpecular )
{
    RenderFrame( 0, pd3dDevice, pEffect, hTechnique, htxDiffuse, htxNormal, htxSpecular );
}

//--------------------------------------------------------------------------------------
D3D10_PRIMITIVE_TOPOLOGY CDXUTSDKMesh::GetPrimitiveType10( SDKMESH_PRIMITIVE_TYPE PrimType )
{
    D3D10_PRIMITIVE_TOPOLOGY retType = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST;

    switch(PrimType)
    {
    case PT_TRIANGLE_LIST:
        retType = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST;
        break;
    case PT_TRIANGLE_STRIP:
        retType = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP;
        break;
    case PT_LINE_LIST:
        retType = D3D10_PRIMITIVE_TOPOLOGY_LINELIST;
        break;
    case PT_LINE_STRIP:
        retType = D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP;
        break;
    case PT_POINT_LIST:
        retType = D3D10_PRIMITIVE_TOPOLOGY_POINTLIST;
        break;
    case PT_TRIANGLE_LIST_ADJ:
        retType = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLELIST_ADJ;
        break;
    case PT_TRIANGLE_STRIP_ADJ:
        retType = D3D10_PRIMITIVE_TOPOLOGY_TRIANGLESTRIP_ADJ;
        break;
    case PT_LINE_LIST_ADJ:
        retType = D3D10_PRIMITIVE_TOPOLOGY_LINELIST_ADJ;
        break;
    case PT_LINE_STRIP_ADJ:
        retType = D3D10_PRIMITIVE_TOPOLOGY_LINESTRIP_ADJ;
        break;
    };

    return retType;
}

//--------------------------------------------------------------------------------------
DXGI_FORMAT CDXUTSDKMesh::GetIBFormat10( UINT iMesh )
{
    switch( m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].IndexType )
    {
    case IT_16BIT:
        return DXGI_FORMAT_R16_UINT;
    case IT_32BIT:
        return DXGI_FORMAT_R32_UINT;
    };
    return DXGI_FORMAT_R16_UINT;
}

//--------------------------------------------------------------------------------------
ID3D10Buffer* CDXUTSDKMesh::GetVB10( UINT iMesh, UINT iVB )
{
    return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].pVB10;
}

//--------------------------------------------------------------------------------------
ID3D10Buffer* CDXUTSDKMesh::GetIB10( UINT iMesh )
{
    return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB10;
}

//--------------------------------------------------------------------------------------
ID3D10Buffer* CDXUTSDKMesh::GetAdjIB10( UINT iMesh )
{
    return m_pAdjacencyIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB10;
}

//--------------------------------------------------------------------------------------
D3DPRIMITIVETYPE CDXUTSDKMesh::GetPrimitiveType9( SDKMESH_PRIMITIVE_TYPE PrimType )
{
    D3DPRIMITIVETYPE retType = D3DPT_TRIANGLELIST;

     switch(PrimType)
    {
    case PT_TRIANGLE_LIST:
        retType = D3DPT_TRIANGLELIST;
        break;
    case PT_TRIANGLE_STRIP:
        retType = D3DPT_TRIANGLESTRIP;
        break;
    case PT_LINE_LIST:
        retType = D3DPT_LINELIST;
        break;
    case PT_LINE_STRIP:
        retType = D3DPT_LINESTRIP;
        break;
    case PT_POINT_LIST:
        retType = D3DPT_POINTLIST;
        break;
    };

    return retType;
}

//--------------------------------------------------------------------------------------
D3DFORMAT CDXUTSDKMesh::GetIBFormat9( UINT iMesh )
{
    switch( m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].IndexType )
    {
    case IT_16BIT:
        return D3DFMT_INDEX16;
    case IT_32BIT:
        return D3DFMT_INDEX32;
    };
    return D3DFMT_INDEX16;
}

//--------------------------------------------------------------------------------------
IDirect3DVertexBuffer9* CDXUTSDKMesh::GetVB9( UINT iMesh, UINT iVB )
{
    return m_pVertexBufferArray[ m_pMeshArray[ iMesh ].VertexBuffers[iVB] ].pVB9;
}

//--------------------------------------------------------------------------------------
IDirect3DIndexBuffer9* CDXUTSDKMesh::GetIB9( UINT iMesh )
{
    return m_pIndexBufferArray[ m_pMeshArray[ iMesh ].IndexBuffer ].pIB9;
}

//--------------------------------------------------------------------------------------
char* CDXUTSDKMesh::GetMeshPathA()
{
    return m_strPath;
}

//--------------------------------------------------------------------------------------
WCHAR* CDXUTSDKMesh::GetMeshPathW()
{
    return m_strPathW;
}

//--------------------------------------------------------------------------------------
UINT CDXUTSDKMesh::GetNumMeshes()
{
    if( !m_pMeshHeader )
        return 0;
    return m_pMeshHeader->NumMeshes;
}

//--------------------------------------------------------------------------------------
UINT CDXUTSDKMesh::GetNumMaterials()
{
    if( !m_pMeshHeader )
        return 0;
    return m_pMeshHeader->NumMaterials;
}

//--------------------------------------------------------------------------------------
UINT CDXUTSDKMesh::GetNumVBs()
{
    if( !m_pMeshHeader )
        return 0;
    return m_pMeshHeader->NumVertexBuffers;
}

//--------------------------------------------------------------------------------------
UINT CDXUTSDKMesh::GetNumIBs()
{
    if( !m_pMeshHeader )
        return 0;
    return m_pMeshHeader->NumIndexBuffers;
}