Blending

void CDXNifMesh::Pass(LPDIRECT3DDEVICE9 pDevice, UInt32 iPass, CDXShader * shader)
{
    ID3DXEffect * effect = shader->GetEffect();
    if (m_material) {
        effect->SetValue(shader->m_hSpecular, m_material->GetSpecularColor(), sizeof(D3DXVECTOR3));
        effect->SetValue(shader->m_hAmbient, m_material->GetAmbientColor(), sizeof(D3DXVECTOR3));
        effect->SetValue(shader->m_hDiffuse, m_material->GetDiffuseColor(), sizeof(D3DXVECTOR3));

        UInt32 alphaFunc = mappedTestFunctions[m_material->GetTestMode()];
        UInt32 srcBlend = mappedAlphaFunctions[m_material->GetSrcBlendMode()];
        UInt32 destBlend = mappedAlphaFunctions[m_material->GetDestBlendMode()];

        bool isDoubleSided = (m_material->GetShaderFlags2() & BSShaderProperty::kSLSF2_Double_Sided) == BSShaderProperty::kSLSF2_Double_Sided;
        bool zBufferTest = (m_material->GetShaderFlags1() & BSShaderProperty::kSLSF1_ZBuffer_Test) == BSShaderProperty::kSLSF1_ZBuffer_Test;
        bool zBufferWrite = (m_material->GetShaderFlags2() & BSShaderProperty::kSLSF2_ZBuffer_Write) == BSShaderProperty::kSLSF2_ZBuffer_Write;

        pDevice->SetRenderState(D3DRS_ZENABLE, zBufferTest ? TRUE : FALSE);
        pDevice->SetRenderState(D3DRS_ZWRITEENABLE, zBufferWrite ? TRUE : FALSE);
        pDevice->SetRenderState(D3DRS_CULLMODE, isDoubleSided ? D3DCULL_NONE : D3DCULL_CCW);
        pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
        pDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, m_material->GetAlphaBlending() ? TRUE : FALSE);
        pDevice->SetRenderState(D3DRS_ALPHATESTENABLE, m_material->GetAlphaTesting() ? TRUE : FALSE);
        pDevice->SetRenderState(D3DRS_ALPHAREF, m_material->GetAlphaThreshold());
        pDevice->SetRenderState(D3DRS_ALPHAFUNC, alphaFunc);
        pDevice->SetRenderState(D3DRS_SRCBLEND, srcBlend);
        pDevice->SetRenderState(D3DRS_DESTBLEND, destBlend);
    }
    effect->CommitChanges();

    CDXMesh::Pass(pDevice, iPass, shader);
}






#include "CDXMaterial.h"

CDXMaterial::CDXMaterial()
{
    m_diffuseTexture = NULL;
    m_specularColor = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_diffuseColor = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_ambientColor = D3DXVECTOR3(1.0f, 1.0f, 1.0f);
    m_alphaThreshold = 0;
    m_shaderFlags1 = 0;
    m_shaderFlags2 = 0;
    SetAlphaBlending(false);
    SetSrcBlendMode(ALPHA_SRCALPHA);
    SetDestBlendMode(ALPHA_INVSRCALPHA);
    SetTestMode(TEST_ALWAYS);
}

CDXMaterial::~CDXMaterial()
{

}

void CDXMaterial::Release()
{
    SetDiffuseTexture(NULL);
}

void CDXMaterial::SetDiffuseTexture(LPDIRECT3DBASETEXTURE9 texture)
{
    if(m_diffuseTexture)
        m_diffuseTexture->Release();
    m_diffuseTexture = texture;
    if(m_diffuseTexture)
        m_diffuseTexture->AddRef();
}

void CDXMaterial::SetAlphaBlending(bool bAlpha)
{
    SetBit(bAlpha, ALPHA_BLEND_MASK);
}

bool CDXMaterial::GetAlphaBlending() const
{
    return GetBit(ALPHA_BLEND_MASK);
}

void CDXMaterial::SetSrcBlendMode(AlphaFunction eSrcBlend)
{
    SetField((UInt16)(eSrcBlend), SRC_BLEND_MASK, SRC_BLEND_POS);
}

CDXMaterial::AlphaFunction CDXMaterial::GetSrcBlendMode() const
{
    return (CDXMaterial::AlphaFunction)GetField(SRC_BLEND_MASK, SRC_BLEND_POS);
}

void CDXMaterial::SetDestBlendMode(AlphaFunction eDestBlend)
{
    SetField((UInt16)(eDestBlend), DEST_BLEND_MASK, DEST_BLEND_POS);
}

CDXMaterial::AlphaFunction CDXMaterial::GetDestBlendMode() const
{
    return (CDXMaterial::AlphaFunction)GetField(DEST_BLEND_MASK, DEST_BLEND_POS);
}

void CDXMaterial::SetAlphaTesting(bool bAlpha)
{
    SetBit(bAlpha, TEST_ENABLE_MASK);
}
//---------------------------------------------------------------------------
bool CDXMaterial::GetAlphaTesting() const
{
    return GetBit(TEST_ENABLE_MASK);
}
//---------------------------------------------------------------------------
void CDXMaterial::SetTestMode(TestFunction eTestFunc)
{
    SetField((UInt16)(eTestFunc), TEST_FUNC_MASK, TEST_FUNC_POS);
}
//---------------------------------------------------------------------------
CDXMaterial::TestFunction CDXMaterial::GetTestMode() const
{
    return (CDXMaterial::TestFunction) GetField(TEST_FUNC_MASK, TEST_FUNC_POS);
}











#ifndef __CDXMATERIAL__
#define __CDXMATERIAL__

#pragma once

#include <d3dx9.h>

#define DeclareFlags(type) \
    private: \
    type m_uFlags; \
    void SetField(type uVal, type uMask, type uPos) \
        { \
        m_uFlags = (m_uFlags & ~uMask) | (uVal << uPos); \
        } \
        type GetField(type uMask, type uPos) const \
        { \
        return (m_uFlags & uMask) >> uPos; \
        } \
        void SetBit(bool bVal, type uMask) \
        { \
        if (bVal) \
            { \
            m_uFlags |= uMask; \
            } \
            else \
            { \
            m_uFlags &= ~uMask; \
            } \
        }\
        bool GetBit(type uMask) const \
        { \
        return (m_uFlags & uMask) != 0; \
        }

static UInt32 mappedAlphaFunctions[] = {
    D3DBLEND_ONE,
    D3DBLEND_ZERO,
    D3DBLEND_SRCCOLOR,
    D3DBLEND_INVSRCCOLOR,
    D3DBLEND_DESTCOLOR,
    D3DBLEND_INVDESTCOLOR,
    D3DBLEND_SRCALPHA,
    D3DBLEND_INVSRCALPHA,
    D3DBLEND_DESTALPHA,
    D3DBLEND_INVDESTALPHA,
    D3DBLEND_SRCALPHASAT
};

static UInt32 mappedTestFunctions[] = {
    D3DCMP_ALWAYS,
    D3DCMP_LESS,
    D3DCMP_EQUAL,
    D3DCMP_LESSEQUAL,
    D3DCMP_GREATER,
    D3DCMP_NOTEQUAL,
    D3DCMP_GREATEREQUAL,
    D3DCMP_NEVER,
};

class CDXMaterial
{
public:
    CDXMaterial::CDXMaterial();
    CDXMaterial::~CDXMaterial();

    void Release();

    void SetDiffuseTexture(LPDIRECT3DBASETEXTURE9 texture);
    LPDIRECT3DBASETEXTURE9 GetDiffuseTexture() const { return m_diffuseTexture; }

    void SetDiffuseColor(D3DXVECTOR3 color) { m_diffuseColor = color; }
    void SetSpecularColor(D3DXVECTOR3 color) { m_specularColor = color; }
    void SetAmbientColor(D3DXVECTOR3 color) { m_ambientColor = color; }

    D3DXVECTOR3 & GetDiffuseColor() { return m_diffuseColor; }
    D3DXVECTOR3 & GetSpecularColor() { return m_specularColor; }
    D3DXVECTOR3 & GetAmbientColor() { return m_ambientColor; }

    UInt32 GetShaderFlags1() const { return m_shaderFlags1; }
    UInt32 GetShaderFlags2() const { return m_shaderFlags2; }

    void SetShaderFlags1(UInt32 flags) { m_shaderFlags1 = flags; }
    void SetShaderFlags2(UInt32 flags) { m_shaderFlags2 = flags; }

    void SetFlags(UInt16 flags) { m_uFlags = flags; }

    enum AlphaFunction
    {
        ALPHA_ONE,
        ALPHA_ZERO,
        ALPHA_SRCCOLOR,
        ALPHA_INVSRCCOLOR,
        ALPHA_DESTCOLOR,
        ALPHA_INVDESTCOLOR,
        ALPHA_SRCALPHA,
        ALPHA_INVSRCALPHA,
        ALPHA_DESTALPHA,
        ALPHA_INVDESTALPHA,
        ALPHA_SRCALPHASAT,
        ALPHA_MAX_MODES
    };

    enum
    {
        ALPHA_BLEND_MASK          = 0x0001,
        SRC_BLEND_MASK      = 0x001e,
        SRC_BLEND_POS       = 1,
        DEST_BLEND_MASK     = 0x01e0,
        DEST_BLEND_POS      = 5,
        TEST_ENABLE_MASK    = 0x0200,
        TEST_FUNC_MASK      = 0x1c00,
        TEST_FUNC_POS       = 10,
        ALPHA_NOSORTER_MASK = 0x2000
    };

    enum TestFunction
    {
        TEST_ALWAYS,
        TEST_LESS,
        TEST_EQUAL,
        TEST_LESSEQUAL,
        TEST_GREATER,
        TEST_NOTEQUAL,
        TEST_GREATEREQUAL,
        TEST_NEVER,
        TEST_MAX_MODES
    };

    void SetAlphaBlending(bool bAlpha);
    bool GetAlphaBlending() const;

    void SetSrcBlendMode(AlphaFunction eSrcBlend);
    AlphaFunction GetSrcBlendMode() const;

    void SetDestBlendMode(AlphaFunction eDestBlend);
    AlphaFunction GetDestBlendMode() const;

    void SetAlphaTesting(bool bAlpha);
    bool GetAlphaTesting() const;

    void SetTestMode(TestFunction eTestFunc);
    TestFunction GetTestMode() const;


    void SetAlphaThreshold(UInt8 thresh) { m_alphaThreshold = thresh; }
    UInt8 GetAlphaThreshold() const { return m_alphaThreshold; }

protected:
    LPDIRECT3DBASETEXTURE9 m_diffuseTexture;

    D3DXVECTOR3 m_specularColor;
    D3DXVECTOR3 m_diffuseColor;
    D3DXVECTOR3 m_ambientColor;
    DeclareFlags(UInt16);
    UInt32  m_shaderFlags1;
    UInt32  m_shaderFlags2;
    UInt8   m_alphaThreshold;
};

#endif