d3dshader.cpp

使用shader语言在vs阶段编写光照效果的演示程序及全部源代码

#include "D3DShader.h"
#include <iostream>
using namespace std;

void IShader::set_float  (const char* Name , float    v  )
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetFloat(m_pD3DDevice,hD3DXHanle,v);
	}
}

void IShader::set_float_array( const char* Name , float*   v  ,int Count)
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetFloatArray(m_pD3DDevice,hD3DXHanle,v,Count);
	}
}

void IShader::set_int  (const char* Name , int      v  )
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetInt(m_pD3DDevice,hD3DXHanle,v);
	}
}

void IShader::set_matrix(const char* Name ,  D3DXMATRIX* mat)
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetMatrix(m_pD3DDevice,hD3DXHanle,mat);
	}
}

void IShader::set_matrix_t(const char* Name ,  D3DXMATRIX* mat)
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetMatrixTranspose(m_pD3DDevice,hD3DXHanle,mat);
	}
}

void IShader::set_int_array(const char* Name , int*      v ,int Count)
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetIntArray(m_pD3DDevice,hD3DXHanle,v,Count);
	}
}

void IShader::set_vector(const char* Name , D3DXVECTOR4*   vec)
{
	if(m_pConstTable == NULL)
		return ;
	D3DXHANDLE hD3DXHanle =  m_pConstTable->GetConstantByName(NULL,Name);
	if(hD3DXHanle)
	{
		m_pConstTable->SetVector(m_pD3DDevice,hD3DXHanle,  vec) ;
	}
}


CPixelShader::CPixelShader()
{
	m_pPixelShader = NULL;
	m_pConstTable = NULL;
}

bool CPixelShader::load(const char* pixelShader,const char* main)
{
	m_pD3DDevice = CD3DApplication::getApp()->getDevice();
	LPD3DXBUFFER pCode;                  // Buffer with the assembled shader code
	LPD3DXBUFFER pErrorMsgs; // Buffer with error messages
	D3DCAPS9 Caps;
	m_pD3DDevice->GetDeviceCaps(&Caps);
	if(bValidPS(Caps.PixelShaderVersion ))
	{
		HRESULT hr = D3DXCompileShaderFromFile(pixelShader,NULL,NULL,main,"ps_2_0",0,&pCode,&pErrorMsgs,&m_pConstTable);
		if(pCode != 0)
		{
			DWORD* pCodeBuffer = NULL;
			try
			{
				pCodeBuffer = (DWORD*)pCode->GetBufferPointer();
				if(pCodeBuffer)
				{
					m_pD3DDevice->CreatePixelShader(pCodeBuffer,&m_pPixelShader);
				}
				pCode->Release();
			}
			catch(...){}
		}
		else
		{
			if(pErrorMsgs)
			{
				char* erromesg = (char*)pErrorMsgs->GetBufferPointer();
				cout<<"Loading Shader Fialed: "<< erromesg<<endl;
			}
		}
	}
	else
	{
		m_pPixelShader = NULL;
	}
	return 1;
}


void CPixelShader::bind()
{
	if(m_pPixelShader)
	{
		m_pD3DDevice->SetPixelShader(m_pPixelShader);
	}
}

void CPixelShader::unbind()
{
	if(m_pPixelShader)
	{
		m_pD3DDevice->SetPixelShader(NULL);
	}

}


bool CPixelShader::bValidPS(DWORD PSversion)
{
	if(PSversion >= D3DPS_VERSION(2,0))
		return true;

	return false;

}
bool CVertexShader::bValidVS(DWORD VSversion)
{
	if(VSversion >= D3DVS_VERSION(2,0))
		return true;

	return false;
}

void CPixelShader::unload()
{
	if(m_pPixelShader)
		m_pPixelShader->Release();
	if(m_pConstTable)
		m_pConstTable->Release();
}


CVertexShader::CVertexShader()
{
	m_pVertexShader = NULL;
	m_pConstTable = NULL;
}

bool CVertexShader::load(const char* pixelShader,const char* main)
{
	m_pD3DDevice = CD3DApplication::getApp()->getDevice();
	LPD3DXBUFFER pCode;                  // Buffer with the assembled shader code
	LPD3DXBUFFER pErrorMsgs;             // Buffer with error messages
	HRESULT hr = D3DXCompileShaderFromFile(pixelShader,NULL,NULL,main,"vs_2_0",0,&pCode,&pErrorMsgs,&m_pConstTable);
	D3DCAPS9 Caps;
	m_pD3DDevice->GetDeviceCaps(&Caps);
	if(bValidVS(Caps.VertexShaderVersion ))
	{
		if(pCode != 0)
		{
			DWORD* pCodeBuffer = NULL;
			pCodeBuffer = (DWORD*)pCode->GetBufferPointer();
			if(pCodeBuffer)
			{
				m_pD3DDevice->CreateVertexShader(pCodeBuffer,&m_pVertexShader);
			}
			pCode->Release();
		}
		else
		{
			if(pErrorMsgs)
			{
				char* erromesg = (char*)pErrorMsgs->GetBufferPointer();
				//MessageBox(NULL,erromesg,"Erro",MB_OK);
				cout<<"Loading Shader Fialed: "<< erromesg<<endl;
			}

		}
	}
	else
	{
		m_pConstTable = NULL;
		m_pVertexShader = NULL;
	}
	return 1;
}

void CVertexShader::bind()
{
	if(m_pVertexShader)
	{
		m_pD3DDevice->SetVertexShader(m_pVertexShader);
	}
}
void CVertexShader::unbind()
{
	if(m_pVertexShader)
	{
		m_pD3DDevice->SetVertexShader(NULL);
	}
}
void CVertexShader::unload()
{
	if(m_pVertexShader)
		m_pVertexShader->Release();
	if(m_pConstTable)
		m_pConstTable->Release();
}