深度测试与alpha混合（5）

透过那些透明度非常高的物体看其他物体，例如透过几乎完全透明的玻璃看其他物体，会感到玻璃好像不存在，在三维图形程序中渲染时就可以不渲染这些透明度非常高的物体，从而可以提高渲染速度，这可以通过alpha测试来实现。

alpha测试根据当前像素是否满足alpha测试条件（即是否达到一定的透明度）来控制是否绘制该像素，图形程序应用alpha测试可以有效地屏蔽某些像素颜色。与alpha混合相比，alpha测试不将当前像素的颜色与颜色缓冲区中像素的颜色混合，像素要么完全不透明，要么完全透明。由于无需进行颜色缓冲区的读操作和颜色混合，因此alpha测试在速度上要优于alpha混合。

alpha测试通过激活渲染状态D3DRS_ALPHATESTENABLE来设置，示例代码如下：

g_device->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);

渲染状态D3DRS_ALPHAREF用来设置alpha测试的参考值，alpha测试函数比较当前绘制的像素的alpha值和参考值，如果返回TRUE，则通过测试并绘制像素，反之不予绘制。参考值的取值范围是0x00000000到0x000000ff。

渲染状态D3DRS_ALPHAFUNC用来设置alpha测试函数，alpha测试函数属于D3DCMPFUNC枚举类型，默认状态为D3DCMP_ALWAYS。下列代码设置alpha测试函数为D3DCMP_GREATER，表示测试点像素的alpha值大于设置的alpha参考值时则返回TRUE：

g_device->SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
g_device->SetRenderState(D3DRS_ALPHAREF, 0x00000081);
g_device->SetRenderState(D3DRS_ALPHAFUNC, D3DCMP_GREATER);

已知蓝色玻璃的alpha值为浮点值0.5f，等价于两位16进制数0x80，小于程序中设置的alpha测试参考值0x81，并且alpha测试函数被设为D3DCMP_GREATER，所以蓝色玻璃的颜色不会被绘制出来。

按下数字键"1"，启用alpha测试。

 

按下数字键"0"，禁用alpha测试。

 

源程序：

#include  < d3dx9.h >

#pragma warning(disable :  4127 )

#define  CLASS_NAME    "GameApp"

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

IDirect3D9 *                 g_d3d;
IDirect3DDevice9 *         g_device;

ID3DXMesh *                 g_mesh;
D3DMATERIAL9 *             g_mesh_materials;
IDirect3DTexture9 **         g_mesh_textures;
DWORD                    g_num_materials;

void  setup_world_matrix()
{
    D3DXMATRIX mat_world;
    D3DXMatrixRotationY( & mat_world, timeGetTime()  /   1000.0f );
    g_device -> SetTransform(D3DTS_WORLD,  & mat_world);
}

void  setup_view_proj_matrices()
{
     //  setup view matrix

    D3DXVECTOR3 eye( 0.0f ,  15.0f ,  - 20.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 ,  500.0f );
    g_device -> SetTransform(D3DTS_PROJECTION,  & mat_proj);
}

bool  init_geometry()
{
    ID3DXBuffer *  material_buffer;

     /*
     D3DXLoadMeshFromXA(
        LPCSTR pFilename, 
        DWORD Options, 
        LPDIRECT3DDEVICE9 pD3DDevice, 
        LPD3DXBUFFER *ppAdjacency,
        LPD3DXBUFFER *ppMaterials, 
        LPD3DXBUFFER *ppEffectInstances, 
        DWORD *pNumMaterials,
        LPD3DXMESH *ppMesh);
     */

     if (FAILED(D3DXLoadMeshFromX( " heli.x " , D3DXMESH_SYSTEMMEM, g_device, NULL,  & material_buffer, NULL,
                                 & g_num_materials,  & g_mesh)))
    {
        MessageBox(NULL,  " Could not find heli.x " ,  " ERROR " , MB_OK);
         return   false ;
    }

    D3DXMATERIAL *  xmaterials  =  (D3DXMATERIAL * ) material_buffer -> GetBufferPointer();

    g_mesh_materials  =   new  D3DMATERIAL9[g_num_materials];
    g_mesh_textures      =   new  IDirect3DTexture9 * [g_num_materials];

     for (DWORD i  =   0 ; i  <  g_num_materials; i ++ )
    {
        g_mesh_materials[i]  =  xmaterials[i].MatD3D;

         //  set ambient reflected coefficient, because .x file do not set it.
        g_mesh_materials[i].Ambient  =  g_mesh_materials[i].Diffuse;

        g_mesh_textures[i]  =  NULL;

         if (xmaterials[i].pTextureFilename  !=  NULL  &&  strlen(xmaterials[i].pTextureFilename)  >   0 )    
            D3DXCreateTextureFromFile(g_device, xmaterials[i].pTextureFilename,  & g_mesh_textures[i]);    
    }

    material_buffer -> Release();

     return   true ;
}

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;
    d3dpp.EnableAutoDepthStencil     =  TRUE;
    d3dpp.AutoDepthStencilFormat     =  D3DFMT_D16;

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

    setup_view_proj_matrices();    

    g_device -> SetRenderState(D3DRS_ZENABLE,            TRUE);
    g_device -> SetRenderState(D3DRS_ZFUNC,            D3DCMP_LESS);
    g_device -> SetRenderState(D3DRS_ZWRITEENABLE,    TRUE);

    g_device -> SetRenderState(D3DRS_ALPHATESTENABLE, TRUE);
    g_device -> SetRenderState(D3DRS_ALPHAREF,         0x00000081 );
    g_device -> SetRenderState(D3DRS_ALPHAFUNC,        D3DCMP_GREATER);    

    g_device -> SetRenderState(D3DRS_AMBIENT,  0xFFFFBB55 );
    
     return   true ;
}

void  cleanup()
{
    delete[] g_mesh_materials;

     if (g_mesh_textures)
    {
         for (DWORD i  =   0 ; i  <  g_num_materials; i ++ )
            release_com(g_mesh_textures[i]);

        delete[] g_mesh_textures;
    }
    
    release_com(g_mesh);
    release_com(g_device);
    release_com(g_d3d);
}

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

    g_device -> BeginScene();

    setup_world_matrix();

     //  render opaque object first
     for (DWORD i  =   0 ; i  <  g_num_materials; i ++ )
    {
         if (g_mesh_materials[i].Diffuse.a  ==   1.0f )
        {
            g_device -> SetMaterial( & g_mesh_materials[i]);
            g_device -> SetTexture( 0 , g_mesh_textures[i]);

            g_mesh -> DrawSubset(i);
        }        
    }        

     //  render transparent object second
     for (DWORD i  =   0 ; i  <  g_num_materials; i ++ )
    {
         if (g_mesh_materials[i].Diffuse.a  !=   1.0f )
        {
            g_device -> SetMaterial( & g_mesh_materials[i]);
            g_device -> SetTexture( 0 , g_mesh_textures[i]);

            g_mesh -> DrawSubset(i);
        }        
    }        
    
    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   48 :  //  press key "0", disable alpha test.
            g_device -> SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);
             break ;

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

         case  VK_ESCAPE:
            DestroyWindow(hwnd);
             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 ,  640 ,  480 ,
                             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 ;
}

 

下载示例工程