桌面 透明 三角形 分层窗口 DX

 //桌面 透明 三角形 分层窗口 DX
 //IDirect3DSurface9 GetDC  UpdateLayeredWindow

 #include <Windows.h>
 #include <mmsystem.h>
 #include <d3dx9.h>
 #pragma warning( disable : 4996 )
 #include <strsafe.h>
 #pragma warning( default : 4996 )

 //include path $(DXSDK_DIR)Include;
 //library path $(DXSDK_DIR)Lib\x86
 //library d3dx9.lib d3d9.lib Winmm.lib

 LPDIRECT3D9             g_pD3D = NULL;
 LPDIRECT3DDEVICE9       g_pd3dDevice = NULL;
 LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;

 HWND g_hWnd = NULL;
 IDirect3DSurface9*        g_pkRenderTarget = NULL;
 IDirect3DSurface9*        g_pkOffscreenPlainSurface = NULL;

 struct CUSTOMVERTEX
 {
     FLOAT x, y, z;
     DWORD color;
 };

 #define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ|D3DFVF_DIFFUSE)

 HRESULT InitD3D(HWND hWnd)
 {
     if (NULL == (g_pD3D = Direct3DCreate9(D3D_SDK_VERSION)))
     {
         return E_FAIL;
     }

     D3DPRESENT_PARAMETERS d3dpp;
     ZeroMemory(&d3dpp, sizeof(d3dpp));
     d3dpp.Windowed = TRUE;
     d3dpp.SwapEffect = D3DSWAPEFFECT_DISCARD;
     d3dpp.BackBufferFormat = D3DFMT_UNKNOWN;

     if (FAILED(g_pD3D->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hWnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING, &d3dpp, &g_pd3dDevice)))
     {
         return E_FAIL;
     }

     g_pd3dDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_NONE);
     g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

     return S_OK;
 }

 HRESULT InitGeometry()
 {
     CUSTOMVERTEX g_Vertices[] =
     {
         { -1.0f, -1.0f, 0.0f, 0xffff0000, },
         { 1.0f, -1.0f, 0.0f, 0xff0000ff, },
         { 0.0f, 1.0f, 0.0f, 0xffffffff, },
     };

     if (FAILED(g_pd3dDevice->CreateVertexBuffer( * sizeof(CUSTOMVERTEX), , D3DFVF_CUSTOMVERTEX, D3DPOOL_DEFAULT, &g_pVB, NULL)))
     {
         return E_FAIL;
     }

     VOID* pVertices;
     if (FAILED(g_pVB->Lock(, sizeof(g_Vertices), (void**)&pVertices, )))
     {
         return E_FAIL;
     }
     memcpy(pVertices, g_Vertices, sizeof(g_Vertices));
     g_pVB->Unlock();

     return S_OK;
 }

 VOID Cleanup()
 {
     if (g_pVB != NULL)
     {
         g_pVB->Release();
     }
     if (g_pd3dDevice != NULL)
     {
         g_pd3dDevice->Release();
     }
     if (g_pD3D != NULL)
     {
         g_pD3D->Release();
     }
 }

 VOID SetupMatrices()
 {
     D3DXMATRIXA16 matWorld;
     UINT iTime = timeGetTime() % ;
     FLOAT fAngle = iTime * (2.0f * D3DX_PI) / 1000.0f;
     D3DXMatrixRotationY(&matWorld, fAngle);
     g_pd3dDevice->SetTransform(D3DTS_WORLD, &matWorld);

     D3DXVECTOR3 vEyePt(0.0f, 3.0f, -5.0f);
     D3DXVECTOR3 vLookatPt(0.0f, 0.0f, 0.0f);
     D3DXVECTOR3 vUpVec(0.0f, 1.0f, 0.0f);
     D3DXMATRIXA16 matView;
     D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUpVec);
     g_pd3dDevice->SetTransform(D3DTS_VIEW, &matView);

     D3DXMATRIXA16 matProj;
     D3DXMatrixPerspectiveFovLH(&matProj, D3DX_PI / , 1.0f, 1.0f, 100.0f);
     g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);

 }

 VOID Render()
 {

     RECT kRect;
     GetWindowRect(g_hWnd, &kRect);

     UINT uiWndWidth = kRect.right - kRect.left;
     UINT uiWndHeight = kRect.bottom - kRect.top;

     if (!g_pkOffscreenPlainSurface)
     {
         g_pd3dDevice->CreateOffscreenPlainSurface(uiWndWidth, uiWndHeight, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &g_pkOffscreenPlainSurface, );
         g_pd3dDevice->CreateRenderTarget(uiWndWidth, uiWndHeight, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, , true, &g_pkRenderTarget, );
     }
     else
     {
         D3DSURFACE_DESC kDesc;
         g_pkOffscreenPlainSurface->GetDesc(&kDesc);

         if (kDesc.Width != uiWndWidth || kDesc.Width != uiWndHeight)
         {
             g_pkOffscreenPlainSurface->Release();
             g_pkRenderTarget->Release();
             g_pd3dDevice->CreateOffscreenPlainSurface(uiWndWidth, uiWndHeight, D3DFMT_X8R8G8B8, D3DPOOL_SYSTEMMEM, &g_pkOffscreenPlainSurface, );
             g_pd3dDevice->CreateRenderTarget(uiWndWidth, uiWndHeight, D3DFMT_X8R8G8B8, D3DMULTISAMPLE_NONE, , true, &g_pkRenderTarget, );
         }
     }

     if (!g_pkOffscreenPlainSurface || !g_pkRenderTarget)
     {
         return;
     }

     HRESULT hr = g_pd3dDevice->SetRenderTarget(, g_pkRenderTarget);
     g_pd3dDevice->Clear(, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(, , ), 1.0f, );

     if (SUCCEEDED(g_pd3dDevice->BeginScene()))
     {
         SetupMatrices();

         g_pd3dDevice->SetStreamSource(, g_pVB, , sizeof(CUSTOMVERTEX));
         g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
         g_pd3dDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, , );

         g_pd3dDevice->EndScene();
     }

     g_pd3dDevice->Present(NULL, NULL, NULL, NULL);

     hr = g_pd3dDevice->GetRenderTargetData(g_pkRenderTarget, g_pkOffscreenPlainSurface);

     HDC hDC = ;
     //g_pkRenderTarget->GetDC(&hDC);
     g_pkOffscreenPlainSurface->GetDC(&hDC);

     POINT kPoint = { ,  };
     SIZE kSize = { uiWndWidth, uiWndHeight };

     BLENDFUNCTION kBlend;
     kBlend.AlphaFormat = AC_SRC_ALPHA;
     kBlend.SourceConstantAlpha = ;
     kBlend.BlendFlags = ;
     kBlend.BlendOp = AC_SRC_OVER;

     UpdateLayeredWindow(g_hWnd, , &kPoint, &kSize, hDC, &kPoint, , &kBlend, ULW_ALPHA);

     g_pkOffscreenPlainSurface->ReleaseDC(hDC);
     //g_pkRenderTarget->ReleaseDC(hDC);
 }

 LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam)
 {
     switch (msg)
     {
     case WM_DESTROY:
         Cleanup();
         PostQuitMessage();
         return ;
     }

     return DefWindowProc(hWnd, msg, wParam, lParam);
 }

 INT WINAPI wWinMain(HINSTANCE hInst, HINSTANCE, LPWSTR, INT)
 {
     UNREFERENCED_PARAMETER(hInst);

     WNDCLASSEX wc =
     {
         sizeof(WNDCLASSEX), CS_CLASSDC, MsgProc, 0L, 0L, GetModuleHandle(NULL), NULL, NULL, NULL, NULL, L"D3D Tutorial", NULL
     };
     RegisterClassEx(&wc);

     g_hWnd = CreateWindowEx(WS_EX_LAYERED, L"D3D Tutorial", L"D3D Tutorial 03: Matrices", WS_POPUP | WS_THICKFRAME, , , , , NULL, NULL, wc.hInstance, NULL);

     if (SUCCEEDED(InitD3D(g_hWnd)))
     {
         if (SUCCEEDED(InitGeometry()))
         {
             ShowWindow(g_hWnd, SW_SHOWDEFAULT);
             UpdateWindow(g_hWnd);

             MSG msg;
             ZeroMemory(&msg, sizeof(msg));
             while (msg.message != WM_QUIT)
             {
                 if (PeekMessage(&msg, NULL, 0U, 0U, PM_REMOVE))
                 {
                     TranslateMessage(&msg);
                     DispatchMessage(&msg);
                 }
                 else
                 {
                     Render();
                 }
             }
         }
     }

     UnregisterClass(L"D3D Tutorial", wc.hInstance);
     return ;
 }