sdkmisc.cpp

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

//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::RemoveLine( int nLineID )
{
    for( int i=0; i<m_LinesList.GetSize(); i++ )
    {
        LINE_NODE* pLineNode = m_LinesList.GetAt(i);
        if( pLineNode && pLineNode->nLineID == nLineID )
        {
            SAFE_DELETE_ARRAY( pLineNode->pVertexList );
            delete pLineNode;
            m_LinesList.SetAt(i, NULL);
        }
    }

    return S_OK;
}


//--------------------------------------------------------------------------------------
HRESULT CDXUTLineManager::RemoveAllLines()
{
    for( int i=0; i<m_LinesList.GetSize(); i++ )
    {
        LINE_NODE* pLineNode = m_LinesList.GetAt(i);
        if( pLineNode )
        {
            SAFE_DELETE_ARRAY( pLineNode->pVertexList );
            delete pLineNode;
        }
    }
    m_LinesList.RemoveAll();

    return S_OK;
}


//--------------------------------------------------------------------------------------
CDXUTTextHelper::CDXUTTextHelper( ID3DXFont* pFont9, ID3DXSprite* pSprite9, ID3DX10Font* pFont10, ID3DX10Sprite* pSprite10, int nLineHeight ) { Init( pFont9, pSprite9, pFont10, pSprite10, nLineHeight ); }
CDXUTTextHelper::CDXUTTextHelper( ID3DXFont* pFont, ID3DXSprite* pSprite, int nLineHeight )     { Init( pFont, pSprite, NULL, NULL, nLineHeight ); }
CDXUTTextHelper::CDXUTTextHelper( ID3DX10Font* pFont, ID3DX10Sprite* pSprite, int nLineHeight ) { Init( NULL, NULL, pFont, pSprite, nLineHeight ); }
CDXUTTextHelper::~CDXUTTextHelper()
{
    SAFE_RELEASE( m_pFontBlendState10 );
}

//--------------------------------------------------------------------------------------
void CDXUTTextHelper::Init( ID3DXFont* pFont9, ID3DXSprite* pSprite9, ID3DX10Font* pFont10, ID3DX10Sprite* pSprite10, int nLineHeight )
{
    m_pFont9 = pFont9;
    m_pSprite9 = pSprite9;
    m_pFont10 = pFont10;
    m_pSprite10 = pSprite10;
    m_clr = D3DXCOLOR(1,1,1,1);
    m_pt.x = 0; 
    m_pt.y = 0; 
    m_nLineHeight = nLineHeight;
    m_pFontBlendState10 = NULL;

    // Create a blend state if a sprite is passed in
    if( pSprite10 )
    {
        ID3D10Device* pDev = NULL;
        pSprite10->GetDevice( &pDev );
        if( pDev )
        {
            D3D10_BLEND_DESC StateDesc;
            ZeroMemory( &StateDesc, sizeof(D3D10_BLEND_DESC) );
            StateDesc.AlphaToCoverageEnable = FALSE;
            StateDesc.BlendEnable[0] = TRUE;
            StateDesc.SrcBlend = D3D10_BLEND_SRC_ALPHA;
            StateDesc.DestBlend = D3D10_BLEND_INV_SRC_ALPHA;
            StateDesc.BlendOp = D3D10_BLEND_OP_ADD;
            StateDesc.SrcBlendAlpha = D3D10_BLEND_ZERO;
            StateDesc.DestBlendAlpha = D3D10_BLEND_ZERO;
            StateDesc.BlendOpAlpha = D3D10_BLEND_OP_ADD;
            StateDesc.RenderTargetWriteMask[0] = 0xf;
            pDev->CreateBlendState( &StateDesc, &m_pFontBlendState10 );

            pDev->Release();
        }
    }
}


//--------------------------------------------------------------------------------------
HRESULT CDXUTTextHelper::DrawFormattedTextLine( const WCHAR* strMsg, ... )
{
    WCHAR strBuffer[512];
    
    va_list args;
    va_start(args, strMsg);
    StringCchVPrintf( strBuffer, 512, strMsg, args );
    strBuffer[511] = L'\0';
    va_end(args);

    return DrawTextLine( strBuffer );
}


//--------------------------------------------------------------------------------------
HRESULT CDXUTTextHelper::DrawTextLine( const WCHAR* strMsg )
{
    if( NULL == m_pFont9 && NULL == m_pFont10 ) 
        return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );

    HRESULT hr;
    RECT rc;
    SetRect( &rc, m_pt.x, m_pt.y, 0, 0 ); 
    if( m_pFont9 )
        hr = m_pFont9->DrawText( m_pSprite9, strMsg, -1, &rc, DT_NOCLIP, m_clr );
    else
        hr = m_pFont10->DrawText( m_pSprite10, strMsg, -1, &rc, DT_NOCLIP, m_clr );
    if( FAILED(hr) )
        return DXTRACE_ERR_MSGBOX( L"DrawText", hr );

    m_pt.y += m_nLineHeight;

    return S_OK;
}


HRESULT CDXUTTextHelper::DrawFormattedTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg, ... )
{
    WCHAR strBuffer[512];
    
    va_list args;
    va_start(args, strMsg);
    StringCchVPrintf( strBuffer, 512, strMsg, args );
    strBuffer[511] = L'\0';
    va_end(args);

    return DrawTextLine( rc, dwFlags, strBuffer );
}


HRESULT CDXUTTextHelper::DrawTextLine( RECT &rc, DWORD dwFlags, const WCHAR* strMsg )
{
    if( NULL == m_pFont9 && NULL == m_pFont10 ) 
        return DXUT_ERR_MSGBOX( L"DrawTextLine", E_INVALIDARG );

    HRESULT hr;
    if( m_pFont9 )
        hr = m_pFont9->DrawText( m_pSprite9, strMsg, -1, &rc, dwFlags, m_clr );
    else
        hr = m_pFont10->DrawText( m_pSprite10, strMsg, -1, &rc, dwFlags, m_clr );
    if( FAILED(hr) )
        return DXTRACE_ERR_MSGBOX( L"DrawText", hr );

    m_pt.y += m_nLineHeight;

    return S_OK;
}


//--------------------------------------------------------------------------------------
void CDXUTTextHelper::Begin()
{
    if( m_pSprite9 )
        m_pSprite9->Begin( D3DXSPRITE_ALPHABLEND | D3DXSPRITE_SORT_TEXTURE );
    if( m_pSprite10 )
    {
        D3D10_VIEWPORT VPs[D3D10_VIEWPORT_AND_SCISSORRECT_OBJECT_COUNT_PER_PIPELINE];
        UINT cVPs = 1;
        ID3D10Device* pd3dDevice = NULL;
        m_pSprite10->GetDevice( &pd3dDevice );
        if( pd3dDevice )
        {
            // Set projection
            pd3dDevice->RSGetViewports(&cVPs, VPs);
            D3DXMATRIXA16 matProjection;
            D3DXMatrixOrthoOffCenterLH(&matProjection, (FLOAT)VPs[0].TopLeftX, (FLOAT)(VPs[0].TopLeftX + VPs[0].Width), (FLOAT)VPs[0].TopLeftY, (FLOAT)(VPs[0].TopLeftY + VPs[0].Height), 0.1f, 10);
            m_pSprite10->SetProjectionTransform(&matProjection);

            m_pSprite10->Begin( D3DX10_SPRITE_SORT_TEXTURE );
            SAFE_RELEASE( pd3dDevice );
        }
    }


}
void CDXUTTextHelper::End()
{
    if( m_pSprite9 )
        m_pSprite9->End();
    if( m_pSprite10 )
    {
        FLOAT			  OriginalBlendFactor[4];
        UINT			  OriginalSampleMask = 0;
        ID3D10BlendState* pOriginalBlendState10 = NULL;
        ID3D10Device*	  pd3dDevice = NULL;

        m_pSprite10->GetDevice( &pd3dDevice );
        if( pd3dDevice )
        {
            // Get the old blend state and set the new one
            pd3dDevice->OMGetBlendState( &pOriginalBlendState10, OriginalBlendFactor, &OriginalSampleMask );
            if( m_pFontBlendState10 )
            {
                FLOAT NewBlendFactor[4] = {0,0,0,0};
                pd3dDevice->OMSetBlendState( m_pFontBlendState10, NewBlendFactor, 0xffffffff );
            }
        }

        m_pSprite10->End();

        // Reset the original blend state
        if( pd3dDevice && pOriginalBlendState10 )
        {
            pd3dDevice->OMSetBlendState( pOriginalBlendState10, OriginalBlendFactor, OriginalSampleMask );
        }
        SAFE_RELEASE( pOriginalBlendState10 );
        SAFE_RELEASE( pd3dDevice );
    }
}

//--------------------------------------------------------------------------------------
HRESULT DXUTSnapD3D9Screenshot( LPCTSTR szFileName )
{
    HRESULT hr = S_OK;
    IDirect3DDevice9* pDev = DXUTGetD3D9Device();
    if( !pDev )
        return E_FAIL;

    IDirect3DSurface9* pBackBuffer = NULL;
    V_RETURN( pDev->GetBackBuffer( 0, 0, D3DBACKBUFFER_TYPE_MONO, &pBackBuffer ) );

    return D3DXSaveSurfaceToFile( szFileName, D3DXIFF_BMP, pBackBuffer, NULL, NULL );
}

//--------------------------------------------------------------------------------------
HRESULT DXUTSnapD3D10Screenshot( LPCTSTR szFileName )
{
    HRESULT hr;
    D3DPRESENT_PARAMETERS pp;
    pp.BackBufferWidth = 320;
    pp.BackBufferHeight = 240;
    pp.BackBufferFormat = D3DFMT_X8R8G8B8;
    pp.BackBufferCount = 1;
    pp.MultiSampleType = D3DMULTISAMPLE_NONE;
    pp.MultiSampleQuality = 0;
    pp.SwapEffect = D3DSWAPEFFECT_DISCARD;
    pp.hDeviceWindow = DXUTGetHWND();
    pp.Windowed = true;
    pp.Flags = 0;
    pp.FullScreen_RefreshRateInHz = 0;
    pp.PresentationInterval = D3DPRESENT_INTERVAL_DEFAULT;
    pp.EnableAutoDepthStencil = false;

    IDirect3DDevice9 *pDev9 = NULL;
    LPDIRECT3D9 pD3D9 = Direct3DCreate9( D3D_SDK_VERSION );
    hr = pD3D9->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &pp, &pDev9 );
    if( FAILED( hr ) )
    {
        hr = pD3D9->CreateDevice( D3DADAPTER_DEFAULT, D3DDEVTYPE_REF, NULL, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &pp, &pDev9 );
        if( FAILED( hr ) )
            return hr;
    }

    // Get D3D10 render target
    ID3D10Texture2D* tex2D;
    ID3D10RenderTargetView* pRTV = DXUTGetD3D10RenderTargetView();
    pRTV->GetResource( (ID3D10Resource**)&tex2D );

    UINT iWidth,iHeight;
    D3D10_TEXTURE2D_DESC desc;
    tex2D->GetDesc( &desc );
    iWidth = (UINT)desc.Width;
    iHeight = (UINT)desc.Height;

    // Create a staging resource
    ID3D10Device* pDev10 = DXUTGetD3D10Device();
    if( !pDev10 )
        return E_FAIL;
    ID3D10Texture2D* pStagingTexture = NULL;
    desc.Usage = D3D10_USAGE_STAGING;
    desc.BindFlags = 0;
    desc.CPUAccessFlags = D3D10_CPU_ACCESS_READ;
    hr = pDev10->CreateTexture2D( &desc, NULL, &pStagingTexture );
    if(FAILED(hr))
        return hr;

    pDev10->CopyResource( pStagingTexture, tex2D );

    // Create D3D9 texture matching size of D3D10 RT
    LPDIRECT3DTEXTURE9 m_pTexture9;
    D3DXCreateTexture(pDev9, iWidth, iHeight, 1, D3DUSAGE_DYNAMIC, D3DFMT_A8R8G8B8, D3DPOOL_SYSTEMMEM, &m_pTexture9 );

    // Copy bits assuming D3D10 RT is 32bit
    D3DLOCKED_RECT rect;
    m_pTexture9->LockRect(0,&rect, NULL, NULL);
    D3D10_MAPPED_TEXTURE2D map;
    pStagingTexture->Map( 0, D3D10_MAP_READ, NULL, &map );
    BYTE *pBits = (BYTE*)rect.pBits;
    BYTE *pColors = (BYTE*)map.pData;
    for (unsigned int i=0;i<iWidth*iHeight*4-8;i+=4) 
    {
        pBits[i]=pColors[i+2];
        pBits[i+1]=pColors[i+1];
        pBits[i+2]=pColors[i];
        pBits[i+3]=pColors[i+3];
    }
    m_pTexture9->UnlockRect(0);
    pStagingTexture->Unmap(0);

    D3DXSaveTextureToFile( szFileName, D3DXIFF_BMP, m_pTexture9, NULL );

    SAFE_RELEASE( pStagingTexture );
    SAFE_RELEASE( m_pTexture9 );
    SAFE_RELEASE( pDev9 );
    SAFE_RELEASE( pD3D9 );

    return S_OK;
}