shader_halo.cpp

游戏编程精华02－含有几十个游戏编程例子

/*********************************************************************NVMH2****
Path:  E:\devrel\NV_SDK_4\DX8\NVEffectsBrowser\Effects\ToonShade
File:  shader_ToonShade.cpp

Copyright (C) 1999, 2000 NVIDIA Corporation
This file is provided without support, instruction, or implied warranty of any
kind.  NVIDIA makes no guarantee of its fitness for a particular purpose and is
not liable under any circumstances for any damages or loss whatsoever arising
from the use or inability to use this file or items derived from it.

Comments:


******************************************************************************/

#include "eb_effect.h"
#include "nvinc.h"
#include "shader_Halo.h"
#include "ComPtr.h"
#include "Constants.h"

using namespace std;

DECLARE_EFFECT_MAIN()

extern "C"
{
	
	__declspec(dllexport) unsigned int GetNumEffects() { return 1; }
	
	__declspec(dllexport) EBEffect* CreateEffect(unsigned int EffectNum)
	{	
		switch(EffectNum)
		{
		case 0:
			return new CShaderHalo();
			break;
		default:
			return NULL;
		}
	}
	
}

// ------------------------------------------------------------------------------
// CShaderHalo Constructor
//
// Description: Nothing to it -- just straight-forward construction
// ------------------------------------------------------------------------------ 
CShaderHalo::CShaderHalo()
: m_pVertexBuffer(NULL), 
  m_pIndexBuffer(NULL),
  m_bWireframe(false),
  m_pUI(NULL),
  m_fRadius(0.0f),
  m_vecCenter(0.0f, 0.0f, 0.0f),
  m_dwNumVerts(0),
  m_dwNumFaces(0),
  m_eDisplayOption(HALO_DISPLAY),
  m_dwToonShader(0),
  m_dwNormalShader(0),
  m_dwHaloShader(0),
  m_fEdgeSize(0.4f)
{
	m_strEffectLocation = "Vertex Shaders\\Render Styles";
	m_strEffectName = "Silhouette Rendering";
	m_strEffectVertexShader = GetFilePath("Halo.nvv");
	m_strEffectPixelShader = "";
	
	D3DXMatrixIdentity(&m_world);
	D3DXMatrixIdentity(&m_view);
	D3DXMatrixIdentity(&m_proj);
}

// ------------------------------------------------------------------------------
// CShaderHalo Destructor
//
// Description: Nothing to it -- just straight-forward destruction
// ------------------------------------------------------------------------------ 
CShaderHalo::~CShaderHalo()
{
	Free(); 
}

// ------------------------------------------------------------------------------
// CShaderHalo::UpdateProperties
//
// Description: This adds options to the menu (click on "File" or right-click
// on the display.
// ------------------------------------------------------------------------------ 
#define STR_INCREASE_EDGE "Silhouette Increase (+)"
#define STR_DECREASE_EDGE "Silhouette Decrease (-)"

void CShaderHalo::UpdateProperties()
{
	EBEffect::UpdateProperties();

	AddProperty(new EBTriggerProperty(STR_INCREASE_EDGE));
	AddProperty(new EBTriggerProperty(STR_DECREASE_EDGE));

	EBEnumProperty* pEnumProp = new EBEnumProperty("Display Options", OBJECT_MEMBER(m_eDisplayOption), EBTYPE_DWORD_PROP);
	
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Halo Rendering", (DWORD)HALO_DISPLAY, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Toon Shading", (DWORD)TOON_DISPLAY, EBTYPE_DWORD_PROP));
	AddProperty(pEnumProp);
	
	AddProperty(new EBProperty("Wireframe", OBJECT_MEMBER(m_bWireframe), EBTYPE_BOOL_PROP));

	// Vertex shaders
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Halo Silhouettes", GetFilePath("Halo.nvv"), EBTYPE_STRING_PROP));
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Normal TnL", GetFilePath("NormalTransform.nvv"), EBTYPE_STRING_PROP));
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Toon Shading", GetFilePath("ToonShade.nvv"), EBTYPE_STRING_PROP));
}


// ------------------------------------------------------------------------------
// CShaderHalo::ConfirmDevice
//
// Description: Performs caps-bit checking to make sure the selected device 
//		supports this demo.  In this particular case we check for nothing!
// ------------------------------------------------------------------------------ 
HRESULT CShaderHalo::ConfirmDevice(D3DCAPS8* pCaps, DWORD dwBehavior, D3DFORMAT Format)
{
	return S_OK;
}

// ------------------------------------------------------------------------------
// CShaderHalo::Initialize
//
// Description: Initialize render-states, vertex shader and vertex buffers
// ------------------------------------------------------------------------------ 
HRESULT CShaderHalo::Initialize(IDirect3DDevice8* pDev)
{
	HRESULT hr;
	
	// get the D3D device 
	m_pD3DDev = pDev;
	pDev->AddRef();
	
	//initialize mouse UI
	RECT rect;
	rect.left = rect.top = 0;
	D3DVIEWPORT8 viewport;
	m_pD3DDev->GetViewport(&viewport);
	rect.bottom = viewport.Height;
	rect.right  = viewport.Width;
	m_pUI = new MouseUI((const RECT)rect);
	
	vector<DWORD> Declaration;
	Declaration.push_back(D3DVSD_STREAM(0));
	Declaration.push_back(D3DVSD_REG(0, D3DVSDT_FLOAT3));
	Declaration.push_back(D3DVSD_REG(1, D3DVSDT_FLOAT3));
	Declaration.push_back(D3DVSD_END());
	
	// Load the two vertex shaders
	m_dwNormalShader = m_dwHaloShader = 0;
	hr = LoadAndCreateShader(GetFilePath("NormalTransform.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwNormalShader);
	if (FAILED(hr))
		return hr;
	
	hr = LoadAndCreateShader(GetFilePath("Halo.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwHaloShader);
	if (FAILED(hr))
		return hr;

	hr = LoadAndCreateShader(GetFilePath("ToonShade.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwToonShader);
	if (FAILED(hr))
		return hr;
	
	// select the just created vertex shader as the thing to transform and light vertices
	hr = m_pD3DDev->SetVertexShader(m_dwNormalShader);
	if (FAILED(hr))
		return hr;
	
	DWORD tempFVF = D3DFVF_XYZ | D3DFVF_NORMAL;
	hr = LoadXFile(GetFilePath("bigship1.x").c_str(), tempFVF);
	if(FAILED(hr))
		return hr;
	
	// use this vertex buffer as our source for vertices
	hr = m_pD3DDev->SetStreamSource(0, m_pVertexBuffer, sizeof(HVertex));
	if (FAILED(hr))
		return hr;
	
	//set index buffer
	m_pD3DDev->SetIndices(m_pIndexBuffer, 0);
	
	//set render states
	m_pD3DDev->SetRenderState(D3DRS_ZENABLE, D3DZB_TRUE);
	m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	m_pD3DDev->SetRenderState(D3DRS_LIGHTING, FALSE);
	m_pD3DDev->SetRenderState(D3DRS_CULLMODE, D3DCULL_CCW);

	m_pD3DDev->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_SRCALPHA);
	m_pD3DDev->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVSRCALPHA);

	LPDIRECT3DTEXTURE8 m_pShadeTexture;
	D3DXCreateTextureFromFile(m_pD3DDev, GetFilePath("64shade.bmp").c_str(), &m_pShadeTexture);
	
	m_pD3DDev->SetTexture(0, m_pShadeTexture);
	
	m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
	
	m_pD3DDev->SetTextureStageState(0, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_POINT);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_POINT);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_NONE);

	m_pD3DDev->SetTextureStageState(0, D3DTSS_COLORARG1, D3DTA_DIFFUSE);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_SELECTARG1);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_COLORARG2, D3DTA_TEXTURE);
	
	D3DXVECTOR4 lightDir(1.0f, 0.0f, -1.0f, 0.0f);
	D3DXVec4Normalize(&lightDir, &lightDir);
	
	m_pD3DDev->SetVertexShaderConstant(CV_LIGHT_DIRECTION, &lightDir, 1);

	D3DXVECTOR4 perturb(1.0f, 0.0f, -1.0f, 0.0f);
	m_pD3DDev->SetVertexShaderConstant(30, &perturb, 1);
	
	D3DXVECTOR4 constNums(0.0f, 0.2f, 1.0f, 30.0f);
	m_pD3DDev->SetVertexShaderConstant(CV_CONSTANTS, &constNums, 1);
	
	//set view matrix depending on the bounding sphere
	D3DXVECTOR3 eye, lookAt, up;
	
	eye.x    = m_vecCenter.x; eye.y    = m_vecCenter.y; eye.z    = -m_fRadius*2;
	lookAt.x = m_vecCenter.x; lookAt.y = m_vecCenter.y; lookAt.z = m_vecCenter.z;
	up.x	 = 0.0f;          up.y     = 1.0f;          up.z     = 0.0f;
	
	m_pD3DDev->SetVertexShaderConstant(CV_EYE, &eye, 1);
	
	D3DXMatrixIdentity(&m_world);
	D3DXMatrixLookAtLH(&m_view, &eye, &lookAt, &up);
	
	D3DXMatrixPerspectiveFovLH(&m_proj,
		D3DXToRadian(60.0f),
		1,
		1.0f,
		100.0f);
	m_pD3DDev->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)&m_proj);
	
	//matrices
	SetVertexShaderMatrices();

	return S_OK;
}

HRESULT CShaderHalo::SetVertexShaderMatrices()
{
	D3DXMATRIX worldViewProjMat, worldITMat, worldMat;
	D3DXMATRIX tempMat;
	
	D3DXMatrixMultiply(&tempMat, &m_pUI->GetRotationMatrix(), &m_pUI->GetTranslationMatrix());
	D3DXMatrixTranspose(&worldMat, &tempMat);
	
	D3DXMatrixIdentity(&worldViewProjMat);
	
	D3DXMatrixMultiply(&worldViewProjMat, &tempMat, &m_view);
	
	D3DXMatrixInverse(&worldITMat, NULL, &tempMat);
	
	D3DXMatrixMultiply(&worldViewProjMat, &worldViewProjMat, &m_proj);
	D3DXMatrixTranspose(&worldViewProjMat, &worldViewProjMat);
	
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWPROJ_0, &worldViewProjMat, 4);
	
	m_pD3DDev->SetVertexShaderConstant(CV_WORLD_IT_0, &worldITMat, 4);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLD_0, &worldMat, 4);
	
	return S_OK;
}

// ------------------------------------------------------------------------------
// CShaderHalo::Free