像素着色器入门

class CIntroductionSharder_Test
{
public:
 CIntroductionSharder_Test(void);
 virtual ~CIntroductionSharder_Test(void);
public:
 HRESULT D3DCreate( LPDIRECT3DDEVICE9 pd3dDevice );
 void Render( LPDIRECT3DDEVICE9 pd3dDevice );
 void SetMatrix( LPDIRECT3DDEVICE9 pd3dDevice );
private:
 IDirect3DVertexBuffer9* m_pVB;
 ID3DXConstantTable*  m_pMultiTexCT;
 IDirect3DPixelShader9* m_pMultiTexPS;

 IDirect3DTexture9*  m_pBaseTex;
 IDirect3DTexture9*  m_pSpotLightTex;
 IDirect3DTexture9*  m_pStringTex;

 D3DXHANDLE    m_BaseTexHandle;
 D3DXHANDLE    m_SpotLightTexHandle;
 D3DXHANDLE    m_StringTexHandle;

 D3DXCONSTANT_DESC  m_BaseTexDesc;
 D3DXCONSTANT_DESC  m_SpotLightTexDesc;
 D3DXCONSTANT_DESC  m_StringTexDesc;
};

////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////struct MultiTexVertex
{
 MultiTexVertex(float x, float y, float z,
  float u0, float v0,
  float u1, float v1,
  float u2, float v2)
 {
   _x =  x;  _y =  y; _z = z;
  _u0 = u0; _v0 = v0;
  _u1 = u1; _v1 = v1;
  _u2 = u2, _v2 = v2;
 }

 float _x, _y, _z;
 float _u0, _v0;
 float _u1, _v1;
 float _u2, _v2;

 static const DWORD FVF;
};
const DWORD MultiTexVertex::FVF = D3DFVF_XYZ | D3DFVF_TEX3;

CIntroductionSharder_Test::CIntroductionSharder_Test(void)
{
 m_pVB = NULL;
 m_pMultiTexCT = NULL;
 m_pMultiTexPS = NULL;

 m_pBaseTex = NULL;
 m_pSpotLightTex = NULL;
 m_pStringTex = NULL;
}

CIntroductionSharder_Test::~CIntroductionSharder_Test(void)
{
 SAFE_RELEASE( m_pVB );
 SAFE_RELEASE( m_pMultiTexCT );
 SAFE_RELEASE( m_pMultiTexPS );

 SAFE_RELEASE( m_pBaseTex );
 SAFE_RELEASE( m_pSpotLightTex );
 SAFE_RELEASE( m_pStringTex );
}

HRESULT CIntroductionSharder_Test::D3DCreate( LPDIRECT3DDEVICE9 pd3dDevice )
{
 if( FAILED( pd3dDevice->CreateVertexBuffer( 6 * sizeof(MultiTexVertex), D3DUSAGE_WRITEONLY, MultiTexVertex::FVF, D3DPOOL_MANAGED, &m_pVB, 0 ) ) )
  return E_FAIL;

 MultiTexVertex* v = 0;
 m_pVB->Lock(0, 0, (void**)&v, 0);

 v[0] = MultiTexVertex(-10.0f, -10.0f, 5.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
 v[1] = MultiTexVertex(-10.0f,  10.0f, 5.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f, 0.0f);
 v[2] = MultiTexVertex( 10.0f,  10.0f, 5.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);

 v[3] = MultiTexVertex(-10.0f, -10.0f, 5.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f);
 v[4] = MultiTexVertex( 10.0f,  10.0f, 5.0f, 1.0f, 0.0f, 1.0f, 0.0f, 1.0f, 0.0f);
 v[5] = MultiTexVertex( 10.0f, -10.0f, 5.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f);

 m_pVB->Unlock();

 ID3DXBuffer* shader      = 0;
 ID3DXBuffer* errorBuffer = 0;

 if( FAILED( D3DXCompileShaderFromFile( "Dwarf\\ps_multitex.txt", 0, 0, "Main", "ps_2_0", D3DXSHADER_DEBUG, &shader, &errorBuffer, &m_pMultiTexCT ) ) )//编译HLSL着色器
  return E_FAIL;

 if( errorBuffer )
 {
  ::MessageBox(0, (char*)errorBuffer->GetBufferPointer(), 0, 0);
  return E_FAIL;
 }

 if( FAILED( pd3dDevice->CreatePixelShader( (DWORD*)shader->GetBufferPointer(), &m_pMultiTexPS ) ) )//创建像素着色器
  return E_FAIL;

 if( FAILED( D3DXCreateTextureFromFile(pd3dDevice, "Dwarf\\checker.jpg", &m_pBaseTex) ) )
  return E_FAIL;

 if( FAILED( D3DXCreateTextureFromFile(pd3dDevice, "Dwarf\\spotlight.bmp", &m_pSpotLightTex) ) )
  return E_FAIL;

 if( FAILED( D3DXCreateTextureFromFile(pd3dDevice, "Dwarf\\text.bmp", &m_pStringTex) ) )
  return E_FAIL;

 pd3dDevice->SetRenderState(D3DRS_LIGHTING, false);

 m_BaseTexHandle      = m_pMultiTexCT->GetConstantByName(0, "BaseTex");//取得常量句柄
 m_SpotLightTexHandle = m_pMultiTexCT->GetConstantByName(0, "SpotLightTex");
 m_StringTexHandle    = m_pMultiTexCT->GetConstantByName(0, "StringTex");

 UINT count;
 m_pMultiTexCT->GetConstantDesc(m_BaseTexHandle,      &m_BaseTexDesc, &count);// 取得常量的描述
 m_pMultiTexCT->GetConstantDesc(m_SpotLightTexHandle, &m_SpotLightTexDesc, &count);
 m_pMultiTexCT->GetConstantDesc(m_StringTexHandle,    &m_StringTexDesc, &count);
 m_pMultiTexCT->SetDefaults(pd3dDevice);

 SetMatrix(pd3dDevice);
 return S_OK;
}

void CIntroductionSharder_Test::SetMatrix( LPDIRECT3DDEVICE9 pd3dDevice )
{
 D3DXMATRIX P;
 D3DXMatrixPerspectiveFovLH( &P, D3DX_PI * 0.25f, 1.0f, 1.0f, 1000.0f);
 pd3dDevice->SetTransform(D3DTS_PROJECTION, &P);
}

void CIntroductionSharder_Test::Render( LPDIRECT3DDEVICE9 pd3dDevice )
{
 D3DXVECTOR3 position( 0.0f, 0.0f, -20.0f );
 D3DXVECTOR3 target(0.0f, 0.0f, 0.0f);
 D3DXVECTOR3 up(0.0f, 1.0f, 0.0f);
 D3DXMATRIX V;
 D3DXMatrixLookAtLH(&V, &position, &target, &up);
 pd3dDevice->SetTransform(D3DTS_VIEW, &V);

 pd3dDevice->SetPixelShader(m_pMultiTexPS);//设置像素着色器
 pd3dDevice->SetFVF(MultiTexVertex::FVF);
 pd3dDevice->SetStreamSource(0, m_pVB, 0, sizeof(MultiTexVertex));

 pd3dDevice->SetTexture(     m_BaseTexDesc.RegisterIndex, m_pBaseTex);
 pd3dDevice->SetSamplerState(m_BaseTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_BaseTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_BaseTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

 // spotlight tex
 pd3dDevice->SetTexture(     m_SpotLightTexDesc.RegisterIndex, m_pSpotLightTex);
 pd3dDevice->SetSamplerState(m_SpotLightTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_SpotLightTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_SpotLightTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);

 // string tex
 pd3dDevice->SetTexture(     m_StringTexDesc.RegisterIndex, m_pStringTex);
 pd3dDevice->SetSamplerState(m_StringTexDesc.RegisterIndex, D3DSAMP_MAGFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_StringTexDesc.RegisterIndex, D3DSAMP_MINFILTER, D3DTEXF_LINEAR);
 pd3dDevice->SetSamplerState(m_StringTexDesc.RegisterIndex, D3DSAMP_MIPFILTER, D3DTEXF_LINEAR);
 
 pd3dDevice->DrawPrimitive(D3DPT_TRIANGLELIST, 0, 2);
}

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

sampler BaseTex;
sampler SpotLightTex;
sampler StringTex;

struct PS_INPUT
{
    float2 base      : TEXCOORD0;
    float2 spotlight : TEXCOORD1;
    float2 text      : TEXCOORD2;
};

struct PS_OUTPUT
{
    vector diffuse : COLOR0;
};

PS_OUTPUT Main(PS_INPUT input)
{
    PS_OUTPUT output = (PS_OUTPUT)0;

    vector b = tex2D(BaseTex,      input.base);
    vector s = tex2D(SpotLightTex, input.spotlight);
    vector t = tex2D(StringTex,    input.text);

    vector c = b * s + t;
    c += 0.1f;

    output.diffuse = c;

    return output;
}

 

//////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////////

HRESULT IDirect3DDevice9::CreatePixelShader//创建像素着色器
(
 CONST DWORD *pFunction,  //已编译着色器代码的指针
 IDirect3DPixelShader9** ppShader//返回一个IDirect3DPixelShader9 接口的指针
);

HRESULT IDirect3DDevice9::SetPixelShader//设置像素着色器
(
 IDirect3DPixelShader9* pShader
);