shader_toonshade.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_ToonShade.h"
#include "ComPtr.h"
#include "Constants.h"
#include "NVFileDialog.h"

using namespace std;

#define STR_LOADMESH "Load .X File Mesh"

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 CShaderToonShade();
			break;
		default:
			return NULL;
		}
	}
	
}

// ------------------------------------------------------------------------------
// CShaderToonShade Constructor
//
// Description: Nothing to it -- just straight-forward construction
// ------------------------------------------------------------------------------ 
CShaderToonShade::CShaderToonShade()
: m_pVertexBuffer(NULL), 
  m_pIndexBuffer(NULL),
  m_pShadeTexture(NULL), 
  m_pEdgeTexture(NULL),
  m_pAttributes(NULL),
  m_pTFactorColors(NULL),
  m_bWireframe(false),
  m_pUI(NULL),
  m_bUseTrilinear(true),
  m_eDisplayOption(TOONDISPLAY_SILHOUETTESANDSHADING),
  m_fRadius(0.0f),
  m_vecCenter(0.0f, 0.0f, 0.0f)
{
	m_strEffectLocation = "Vertex Shaders\\Render Styles";
	m_strEffectName = "Toon Shading";
	m_strEffectVertexShader = GetFilePath("ToonShade.nvv");
	m_strEffectPixelShader = "";
	
	D3DXMatrixIdentity(&m_world);
	D3DXMatrixIdentity(&m_view);
	D3DXMatrixIdentity(&m_proj);
}

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

// ------------------------------------------------------------------------------
// CShaderToonShade::UpdateProperties
//
// Description: This adds options to the menu (click on "File" or right-click
// on the display.
// ------------------------------------------------------------------------------ 
void CShaderToonShade::UpdateProperties()
{
	EBEffect::UpdateProperties();
	EBEnumProperty* pEnumProp = new EBEnumProperty("Display Options", OBJECT_MEMBER(m_eDisplayOption), EBTYPE_DWORD_PROP);
	
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Silhouettes only", (DWORD)TOONDISPLAY_SILHOUETTES, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Shading only", (DWORD)TOONDISPLAY_SHADING, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Silhouettes and Shading", (DWORD)TOONDISPLAY_SILHOUETTESANDSHADING, EBTYPE_DWORD_PROP));
	
	AddProperty(pEnumProp);
	AddProperty(new EBProperty("Wireframe", OBJECT_MEMBER(m_bWireframe), EBTYPE_BOOL_PROP));
	AddProperty(new EBTriggerProperty(STR_LOADMESH));

	// Vertex shaders
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Toon Lighting", GetFilePath("ToonShade.nvv"), EBTYPE_STRING_PROP));

}


// ------------------------------------------------------------------------------
// CShaderToonShade::ConfirmDevice
//
// Description: Performs caps-bit checking to make sure the selected device 
//		supports this demo.  In this particular case we check for nothing!
// ------------------------------------------------------------------------------ 
HRESULT CShaderToonShade::ConfirmDevice(D3DCAPS8* pCaps, DWORD dwBehavior, D3DFORMAT Format)
{
	if (!(pCaps->TextureCaps & D3DPTEXTURECAPS_MIPMAP))
	{
		m_strLastError = "Device does not support mipmaps!";
		return E_FAIL;
	}

	if (!(pCaps->TextureCaps & D3DPTFILTERCAPS_MIPFLINEAR))
	{
		m_bUseTrilinear = false;
	}

	if(pCaps->MaxSimultaneousTextures < 2)
	{
		m_strLastError = "Device does not support two simultaneous textuers!";
		return E_FAIL;
	}

	return S_OK;
}

HRESULT CShaderToonShade::SetBuffers()
{
	HRESULT hr = m_pD3DDev->SetStreamSource(0, m_pVertexBuffer, sizeof(TSVertex));
	if (FAILED(hr))
		return hr;
	
	//set index buffer
	hr = m_pD3DDev->SetIndices(m_pIndexBuffer, 0);
	if(FAILED(hr))
		return hr;

	return S_OK;
}
	
// ------------------------------------------------------------------------------
// CShaderToonShade::Initialize
//
// Description: Initialize render-states, vertex shader and vertex buffers
// ------------------------------------------------------------------------------ 
HRESULT CShaderToonShade::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_REG(2, D3DVSDT_FLOAT1));
	Declaration.push_back(D3DVSD_REG(3, D3DVSDT_FLOAT1));
	Declaration.push_back(D3DVSD_END());
	
	// Load the vertex shader object file and create it.
	m_dwCurrentShader = 0;
	hr = LoadAndCreateShader(GetFilePath("ToonShade.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwCurrentShader);
	if (FAILED(hr))
		return hr;
	
	// select the just created vertex shader as the thing to transform and light vertices
	hr = m_pD3DDev->SetVertexShader(m_dwCurrentShader);
	if (FAILED(hr))
		return hr;
	
	DWORD tempFVF2;
	D3DXFVFFromDeclarator(&Declaration[0], &tempFVF2);
	
	DWORD tempFVF = D3DFVF_XYZ | D3DFVF_NORMAL | D3DFVF_TEX2 | D3DFVF_TEXCOORDSIZE1(0) | D3DFVF_TEXCOORDSIZE1(1);
	hr = LoadXFile(GetFilePath("bigship1.x").c_str(), tempFVF);
	if(FAILED(hr))
		return hr;
	
	hr = SetBuffers();
	if(FAILED(hr))
		return hr;

	//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);
	
	//load textures
	D3DXCreateTextureFromFile(m_pD3DDev, GetFilePath("edgeimage.dds").c_str(), &m_pEdgeTexture);
	D3DXCreateTextureFromFile(m_pD3DDev, GetFilePath("64shade.bmp").c_str(), &m_pShadeTexture);
	
	m_pD3DDev->SetTexture(0, m_pShadeTexture);
	m_pD3DDev->SetTexture(1, m_pEdgeTexture);
	
	m_pD3DDev->SetTextureStageState(0, D3DTSS_TEXCOORDINDEX, 0);
	m_pD3DDev->SetTextureStageState(1, D3DTSS_TEXCOORDINDEX, 1);
	
	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(1, D3DTSS_ADDRESSU, D3DTADDRESS_CLAMP);
	m_pD3DDev->SetTextureStageState(1, D3DTSS_MINFILTER, D3DTEXF_POINT);
	m_pD3DDev->SetTextureStageState(1, D3DTSS_MAGFILTER, D3DTEXF_POINT);
	if(m_bUseTrilinear)
		m_pD3DDev->SetTextureStageState(1, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);
		
	D3DXVECTOR4 lightDir(1.0f, 0.0f, -1.0f, 0.0f);
	D3DXVec4Normalize(&lightDir, &lightDir);
	
	m_pD3DDev->SetVertexShaderConstant(CV_LIGHT_DIRECTION, &lightDir, 1);
	
	D3DXVECTOR4 constNums(0.0f, 0.5f, 1.0f, -1.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,
		1000.0f);
	m_pD3DDev->SetTransform(D3DTS_PROJECTION, (D3DMATRIX*)&m_proj);
	
	//matrices
	SetVertexShaderMatrices();
	
	return S_OK;
}

HRESULT CShaderToonShade::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);