Direct3D 融合技术与透明效果实现

透明度与 Alpha 通道

在融合中，顶点颜色的 Alpha 分量和材质属性是关键。顶点的 Alpha 分量沿三角形表面渐变，它不直接决定颜色，而是决定透明度。

假设 Alpha 分量占用 8 位，合法区间为 [0, 255]，对应透明度 [0%, 100%]。Alpha 值为 0 表示完全透明，255 表示完全不透明。

要利用 Alpha 描述透明度，通常将源融合因子设为 D3DBLEND_SRCALPHA，目标融合因子设为 D3DBLEND_INVSRCALPHA。这恰好也是 Direct3D 的默认配置。

Alpha 来源

我们通常不从计算中得到 Alpha，而是直接从纹理的 Alpha 通道读取。当纹理映射到图元时，Alpha 通道信息也随之映射成为像素的 Alpha 分量。

默认情况下，如果纹理有 Alpha 通道，Alpha 值取自该通道；否则取自顶点颜色。也可以通过以下状态显式指定：

// 从漫反射颜色计算 Alpha
Device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_DIFFUSE);
Device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);

// 从纹理 Alpha 通道获取
Device->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
Device->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);

实战代码示例

下面是一个完整的 D3D9 初始化及渲染流程示例，展示了如何设置融合状态并绘制带透明度的纹理。

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

LPDIRECT3D9 g_pD3D = NULL;
LPDIRECT3DDEVICE9 g_pd3dDevice = NULL;
LPDIRECT3DVERTEXBUFFER9 g_pVB = NULL;
LPDIRECT3DINDEXBUFFER9 g_pIB = NULL;
LPDIRECT3DTEXTURE9 g_pTexture = NULL;

struct CUSTOMVERTEX {
    FLOAT x, y, z;
    FLOAT tu, tv;
};
#define D3DFVF_CUSTOMVERTEX (D3DFVF_XYZ | D3DFVF_TEX1)

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

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

HRESULT InitGeometry() {
    if (FAILED(D3DXCreateTextureFromFile(g_pd3dDevice, L"cratealpha.dds", &g_pTexture))) {
        return E_FAIL;
    }

    CUSTOMVERTEX vertices[] = {
        { -10.0f, -10.0f, 0.0f, 0, 1 },
        { -10.0f, 10.0f, 0.0f, 0, 0 },
        { 10.0f, 10.0f, 0.0f, 1, 0 },
        { 10.0f, -10.0f, 0.0f, 1, 1 },
    };

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

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

    WORD indices[] = { 0, 1, 2, 0, 2, 3 };
    if (FAILED(g_pd3dDevice->CreateIndexBuffer(sizeof(indices) / sizeof(indices[0]) * sizeof(WORD),
        0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &g_pIB, NULL))) {
        return E_FAIL;
    }

    VOID* pIndices = NULL;
    if (FAILED(g_pIB->Lock(0, sizeof(indices), (void**)&pIndices, 0))) return E_FAIL;
    memcpy(pIndices, (VOID*)indices, sizeof(indices));
    g_pIB->Unlock();

    return S_OK;
}

VOID SetupMatrices() {
    D3DXVECTOR3 vEyePt(0.0f, 0.0f, -30);
    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 / 4, 1.0f, 1.0f, 200.0f);
    g_pd3dDevice->SetTransform(D3DTS_PROJECTION, &matProj);
}

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

VOID Render() {
    g_pd3dDevice->Clear(0, NULL, D3DCLEAR_TARGET | D3DCLEAR_ZBUFFER,
        D3DCOLOR_XRGB(255, 255, 255), 1.0f, 0);

    if (SUCCEEDED(g_pd3dDevice->BeginScene())) {
        SetupMatrices();
        g_pd3dDevice->SetTexture(0, g_pTexture);
        g_pd3dDevice->SetStreamSource(0, g_pVB, 0, sizeof(CUSTOMVERTEX));
        g_pd3dDevice->SetFVF(D3DFVF_CUSTOMVERTEX);
        g_pd3dDevice->SetIndices(g_pIB);
        g_pd3dDevice->SetRenderState(D3DRS_LIGHTING, FALSE);

        // 关键步骤：设置 Alpha 来源为纹理通道
        g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAARG1, D3DTA_TEXTURE);
        g_pd3dDevice->SetTextureStageState(0, D3DTSS_ALPHAOP, D3DTOP_SELECTARG1);

        // 关键步骤：启用 Alpha 混合
        g_pd3dDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
        g_pd3dDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);
        g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);

        g_pd3dDevice->DrawIndexedPrimitive(D3DPT_TRIANGLELIST, 0, 0, 4, 0, 2);

        // 绘制完成后立即关闭混合，避免影响后续不透明物体
        g_pd3dDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);

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

LRESULT WINAPI MsgProc(HWND hWnd, UINT msg, WPARAM wParam, LPARAM lParam) {
    switch (msg) {
    case WM_DESTROY:
        Cleanup();
        PostQuitMessage(0);
        return 0;
    }
    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);

    HWND hWnd = CreateWindow(L"D3D Tutorial", L"D3D Tutorial 03: CreateAlpha",
        WS_OVERLAPPEDWINDOW, 100, 100, 700, 700, NULL, NULL, wc.hInstance, NULL);

    if (SUCCEEDED(InitD3D(hWnd))) {
        if (SUCCEEDED(InitGeometry())) {
            ShowWindow(hWnd, SW_SHOWDEFAULT);
            UpdateWindow(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 0;
}

这段代码演示了如何初始化设备、创建几何体，并在渲染循环中正确配置混合状态。注意在绘制透明物体后，我立即将 ALPHABLENDENABLE 设回 FALSE，这是为了防止后续的不透明物体受到残留的混合状态影响，这是一个容易忽略但至关重要的细节。