深度测试与alpha混合（3）

alpha源混合系数通常设置为D3DBLEND_SRCALPHA，即当前绘制像素的alpha值。目标混合系数设置为D3DBLEND_INVSRCALPHA，即1减去当前绘制像素的alpha值。那么当前绘制像素的alpha值又是如何得到的呢？如果没有使用材质和纹理，当前绘制像素的alpha值来自每个顶点颜色设置的alpha值；如果使用光照和材质，则当前像素的alpha值来自物体表面材质；如果为物体表面使用了纹理，则alpha值还与纹理有关。

顶点alpha

如果在程序中直接指定每个顶点的颜色，则可以直接给出每个顶点颜色的 alpha值，可以在定义顶点时直接声明该顶点的alpha值，也可以在程序运行时动态地修改顶点的alpha值。有了顶点的alpha值，渲染对象中每个像素的alpha值由该对象的alpha值和着色模式决定。当着色模式为FLAT着色模式时，构成对象的各个多边形中所有像素的alpha都等于该多边形的第一个顶点的alpha值。当着色模式为GOURAUD着色模式时，每个多边形面上的像素的alpha值由它的各个顶点的alpha值进行线性插值得到的。

示例程序:

圆筒在不断的绕x, y, z轴旋转。

按下数字键"1"，启用alpha顶点混合

按下数字键"0"，禁用alpha顶点混合

源程序：

#include <d3dx9.h>

#pragma warning(disable : 4127)    // disable warning: conditional expression is constant

#define CLASS_NAME    "GameApp"

#define release_com(p)    do { if(p) { (p)->Release(); (p) = NULL; } } while(0)

typedef unsigned char uchar;

IDirect3D9*                g_d3d;
IDirect3DDevice9*        g_device;
IDirect3DVertexBuffer9* g_vertex_buffer;

struct sCustomVertex
{
    float x, y, z;
    DWORD color;
};

#define D3DFVF_CUSTOM_VERTEX (D3DFVF_XYZ | D3DFVF_DIFFUSE) 

void setup_world_matrix()
{
    D3DXMATRIX mat_world;
    D3DXMatrixIdentity(&mat_world);

    float angle = (timeGetTime() % 1000) * (2 * D3DX_PI) / 1000.0f;

    D3DXQUATERNION quat;
    D3DXMATRIX mat_rotation;

    D3DXQuaternionRotationYawPitchRoll(&quat, angle, angle, angle);
    D3DXMatrixRotationQuaternion(&mat_rotation, &quat);
    D3DXMatrixMultiply(&mat_world, &mat_rotation, &mat_world);

    g_device->SetTransform(D3DTS_WORLD, &mat_world);
}

void setup_view_proj_matrices()
{
    // setup view matrix

    D3DXVECTOR3 eye(0.0f, 3.0f, -5.0f);
    D3DXVECTOR3 at(0.0f,  0.0f,   0.0f);
    D3DXVECTOR3 up(0.0f,  1.0f,   0.0f);

    D3DXMATRIX mat_view;
    D3DXMatrixLookAtLH(&mat_view, &eye, &at, &up);
    g_device->SetTransform(D3DTS_VIEW, &mat_view);

    // setup projection matrix
    D3DXMATRIX mat_proj;
    D3DXMatrixPerspectiveFovLH(&mat_proj, D3DX_PI/4, 1.0f, 1.0f, 100.0f);
    g_device->SetTransform(D3DTS_PROJECTION, &mat_proj);
}

void init_vb()
{    
    g_device->CreateVertexBuffer(50 * 2 * sizeof(sCustomVertex), 0, D3DFVF_CUSTOM_VERTEX, D3DPOOL_DEFAULT, 
                                 &g_vertex_buffer, NULL);

    sCustomVertex* vertices;

    g_vertex_buffer->Lock(0, 0, (void**)&vertices, 0);

    for(int i = 0; i < 50; i++)
    {
        float theta = (2 * D3DX_PI * i) / (50 - 1);

        vertices[2 * i + 0].x      = sin(theta);
        vertices[2 * i + 0].y      = -1.0f;
        vertices[2 * i + 0].z      = cos(theta);            
        vertices[2 * i + 0].color = 0x88FF0000;

        vertices[2 * i + 1].x      = sin(theta);
        vertices[2 * i + 1].y      = 1.0f;
        vertices[2 * i + 1].z      = cos(theta);            
        vertices[2 * i + 1].color = 0x8844FF00;
    }
    
    g_vertex_buffer->Unlock();
}

bool init_d3d(HWND hwnd)
{
    g_d3d = Direct3DCreate9(D3D_SDK_VERSION);

    if(g_d3d == NULL)
        return false;

    D3DPRESENT_PARAMETERS d3dpp;
    ZeroMemory(&d3dpp, sizeof(d3dpp));

    d3dpp.Windowed            = TRUE;
    d3dpp.SwapEffect        = D3DSWAPEFFECT_DISCARD;
    d3dpp.BackBufferFormat    = D3DFMT_UNKNOWN;

    if(FAILED(g_d3d->CreateDevice(D3DADAPTER_DEFAULT, D3DDEVTYPE_HAL, hwnd, D3DCREATE_SOFTWARE_VERTEXPROCESSING,
                                  &d3dpp, &g_device)))
    {
        return false;
    }

    init_vb();
    setup_view_proj_matrices();

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

    g_device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
    g_device->SetRenderState(D3DRS_SRCBLEND,  D3DBLEND_SRCALPHA);
    g_device->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

    return true;
}

void cleanup()
{
    release_com(g_vertex_buffer);
    release_com(g_device);
    release_com(g_d3d);
}

inline void extract_argb(D3DCOLOR color, uchar* alpha, uchar* red, uchar* green, uchar* blue)
{
    // Extract alpha, red, green, blue from D3D color value.

    if(alpha != NULL) *alpha = uchar((color >> 24) & 0xff);
    if(red   != NULL) *red   = uchar((color >> 16) & 0xff);
    if(green != NULL) *green = uchar((color >> 8) & 0xff);
    if(blue  != NULL) *blue  = uchar(color & 0xff);
}

void render()
{
    g_device->Clear(0, NULL, D3DCLEAR_TARGET, D3DCOLOR_XRGB(5, 5, 5), 1.0f, 0);    

    g_device->BeginScene();

    setup_world_matrix();

    g_device->SetStreamSource(0, g_vertex_buffer, 0, sizeof(sCustomVertex));
    g_device->SetFVF(D3DFVF_CUSTOM_VERTEX);
    g_device->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2 * 50 - 2);

    // change all vertices's color and alpha 

    sCustomVertex* vertex;

    g_vertex_buffer->Lock(0, 50 * 2 * sizeof(sCustomVertex), (void**)&vertex, 0);

    for(int i = 0; i < 50 * 2; i++)
    {    
        uchar alpha, red, green, blue;
        extract_argb(vertex->color, &alpha, &red, &green, &blue);

        if(++alpha > 255)    alpha = 0;
        if(++red > 255)        red = 0;
        if(++green > 255)    green = 0;
        if(++blue > 255)    blue = 0;

        vertex->color = D3DCOLOR_RGBA(red, green, blue, alpha);

        vertex++;
    }    

    g_vertex_buffer->Unlock();

    g_device->EndScene();

    g_device->Present(NULL, NULL, NULL, NULL);
}

LRESULT WINAPI WinProc(HWND hwnd, UINT msg, WPARAM wParam, LPARAM lParam)
{
    switch(msg)
    {
    case WM_KEYDOWN:
        switch(wParam)
        {
        case VK_ESCAPE:
            DestroyWindow(hwnd);
            break;

        case 48:    // press key "0", disable alpha blend.
            g_device->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
            break;

        case 49:    // press key "1", enable alpha blend.
            g_device->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
            break;
        }        
            
        break;

    case WM_DESTROY:        
        PostQuitMessage(0);
        return 0;
    }

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

int WINAPI WinMain(HINSTANCE inst, HINSTANCE, LPSTR, INT)
{
    WNDCLASSEX wc;

    wc.cbSize            = sizeof(WNDCLASSEX);
    wc.style            = CS_CLASSDC;
    wc.lpfnWndProc        = WinProc;
    wc.cbClsExtra        = 0;
    wc.cbWndExtra        = 0;
    wc.hInstance        = inst;
    wc.hIcon            = NULL;
    wc.hCursor            = NULL;
    wc.hbrBackground    = NULL;
    wc.lpszMenuName        = NULL;
    wc.lpszClassName    = CLASS_NAME;
    wc.hIconSm            = NULL;

    if(! RegisterClassEx(&wc))
        return -1;

    HWND hwnd = CreateWindow(CLASS_NAME, "Direct3D App", WS_OVERLAPPEDWINDOW, 200, 100, 600, 500,
                             NULL, NULL, wc.hInstance, NULL);

    if(hwnd == NULL)
        return -1;

    if(init_d3d(hwnd))
    {
        ShowWindow(hwnd, SW_SHOWDEFAULT);
        UpdateWindow(hwnd);

        MSG msg;
        ZeroMemory(&msg, sizeof(msg));

        while(msg.message != WM_QUIT)
        {
            if(PeekMessage(&msg, NULL, 0, 0, PM_REMOVE))
            {
                TranslateMessage(&msg);
                DispatchMessage(&msg);
            }
                
            render();
            Sleep(10);
        }
    }

    cleanup();
    UnregisterClass(CLASS_NAME, wc.hInstance);    

    return 0;
}