shader_morph.cpp

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

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

  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 "nvdevice.h"
#include "nvmesh.h"
#include "nvfile.h"
#include "shader_Morph.h"
#include "morph.h"

using namespace nv_objects;
using namespace std;

DECLARE_EFFECT_MAIN()

extern "C"
{

__declspec(dllexport) unsigned int GetNumEffects() { return 1; }

__declspec(dllexport) EBEffect* CreateEffect(unsigned int EffectNum)
{
	return new CShaderMorph();
}

}

CShaderMorph::CShaderMorph()
	: m_pDolphinMap(NULL),
		m_pFloorMesh(NULL),
		m_fWeight(0.0f),
		m_pDolphinIB(NULL),
		m_pNVDevice(NULL),
		m_dwNumVertices(0),
		m_dwNumIndices(0),
		m_bWireframe(false),
		m_bPause(false)
{
	m_pDolphinVB[0] = NULL;
	m_pDolphinVB[1] = NULL;
	m_pDolphinVB[2] = NULL;

	m_strEffectLocation = "Vertex Shaders\\Deformation";
	m_strEffectName = "Morphing Dolphin";
	m_strEffectVertexShader = GetFilePath("Morph.nvv");
	m_strEffectPixelShader = "";

}

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

	AddProperty(new EBProperty("Wireframe", OBJECT_MEMBER(m_bWireframe), EBTYPE_BOOL_PROP));
	AddProperty(new EBProperty("Pause", OBJECT_MEMBER(m_bPause), EBTYPE_BOOL_PROP));
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Vertex Tweening", GetFilePath("Morph.nvv"), EBTYPE_STRING_PROP));
}

CShaderMorph::~CShaderMorph()
{
	Free();	
}

HRESULT CShaderMorph::Initialize(IDirect3DDevice8* pDev)
{
	HRESULT hr;
	DWORD i;
	D3DXMATRIX matView;
	D3DXMATRIX matProj;

	m_pD3DDev = pDev;
	pDev->AddRef();

	m_pNVDevice = new NVMorphDevice(pDev, this);

	DWORD dwVBFlags = D3DUSAGE_WRITEONLY;

	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_FLOAT2));
	Declaration.push_back(D3DVSD_END());

	m_dwSeaFloorShader = 0;
	hr = LoadAndCreateShader(GetFilePath("Morph_SeaFloor.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwSeaFloorShader);
	if (FAILED(hr))
		return hr;
	
	Declaration.clear();
	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_FLOAT2));
	Declaration.push_back(D3DVSD_STREAM(1));
	Declaration.push_back(D3DVSD_REG(3, D3DVSDT_FLOAT3));
	Declaration.push_back(D3DVSD_REG(4, D3DVSDT_FLOAT3));
	Declaration.push_back(D3DVSD_REG(5, D3DVSDT_FLOAT2));
	Declaration.push_back(D3DVSD_END());

	m_dwDolphinShader = 0;
	hr = LoadAndCreateShader(GetFilePath("Morph.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwDolphinShader);
	if (FAILED(hr))
		return hr;


    NVFile* pDolphinGroupObject = new NVFile();
    hr  = pDolphinGroupObject->Create(m_pNVDevice, GetFilePath("dolphin_group.x"));
	if (FAILED(hr))
	{
		m_strLastError = "Could not load dolphin group";
		return hr;
	}
	
	NVMesh* pDolphinMesh[3];
    pDolphinMesh[0] = (NVMesh*)pDolphinGroupObject->FindMesh( "Dolph01" );
    pDolphinMesh[1] = (NVMesh*)pDolphinGroupObject->FindMesh( "Dolph02" );
    pDolphinMesh[2] = (NVMesh*)pDolphinGroupObject->FindMesh( "Dolph03" );
	pDolphinMesh[0]->SetFVF(m_pNVDevice, DOLPHINVERTEX_FVF);
	pDolphinMesh[1]->SetFVF(m_pNVDevice, DOLPHINVERTEX_FVF);
	pDolphinMesh[2]->SetFVF(m_pNVDevice, DOLPHINVERTEX_FVF);

	D3DVERTEXBUFFER_DESC ddsdDescDolphinVB;
	D3DVERTEXBUFFER_DESC ddsdDescSrcVB;
	D3DINDEXBUFFER_DESC ddsdDescDolphinIB;

	for (i = 0; i < 3; i++)
	{
		LPDIRECT3DVERTEXBUFFER8 pSrcVB;
		pDolphinMesh[i]->GetSysMemMesh()->GetVertexBuffer(&pSrcVB);

		pSrcVB->GetDesc(&ddsdDescSrcVB);

		pDev->CreateVertexBuffer(ddsdDescSrcVB.Size, D3DUSAGE_WRITEONLY, 0, D3DPOOL_MANAGED, &m_pDolphinVB[i]);

		m_pDolphinVB[i]->GetDesc(&ddsdDescDolphinVB);

		BYTE* pSrc;
		BYTE* pDest;
		m_pDolphinVB[i]->Lock(0, ddsdDescDolphinVB.Size, &pDest, D3DLOCK_NOSYSLOCK);
		pSrcVB->Lock(0, ddsdDescSrcVB.Size, &pSrc, D3DLOCK_NOSYSLOCK);

		memcpy(pDest, pSrc, ddsdDescSrcVB.Size);

		pSrcVB->Unlock();
		m_pDolphinVB[i]->Unlock();

		SAFE_RELEASE(pSrcVB);
	}

	pDolphinMesh[0]->GetSysMemMesh()->GetIndexBuffer(&m_pDolphinIB);

	m_pDolphinIB->GetDesc(&ddsdDescDolphinIB);
	m_pDolphinVB[0]->GetDesc(&ddsdDescDolphinVB);

	m_dwNumVertices = ddsdDescDolphinVB.Size / sizeof(DolphinVertex);
	switch(ddsdDescDolphinIB.Format)
	{
		case D3DFMT_INDEX16:
			m_dwNumIndices = ddsdDescDolphinIB.Size / 2;
			break;
		case D3DFMT_INDEX32:
			m_dwNumIndices = ddsdDescDolphinIB.Size / 2;
			break;
	}

	SAFE_DELETE(pDolphinGroupObject);

	
	hr = D3DXCreateTextureFromFileEx(m_pD3DDev, 
		GetFilePath("dolphin.dds").c_str(),
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		0,
		0,
		D3DFMT_UNKNOWN,
		D3DPOOL_MANAGED,
		D3DX_FILTER_LINEAR,
		D3DX_FILTER_LINEAR,
		0,
		NULL,
		NULL,
		&m_pDolphinMap);
	if (FAILED(hr))
	{
		m_strLastError = "Could not create dolphin.dds";
		return hr;
	}

    for( DWORD t=0; t<32; t++ )
    {
        TCHAR strTextureName[80];
		LPDIRECT3DTEXTURE8 pTexture;
        sprintf( strTextureName, "Caust%02ld.dds", t );
        
		hr = D3DXCreateTextureFromFileEx(m_pD3DDev, 
			GetFilePath(strTextureName).c_str(),
			D3DX_DEFAULT,
			D3DX_DEFAULT,
			0,
			0,
			D3DFMT_UNKNOWN,
			D3DPOOL_MANAGED,
			D3DX_FILTER_LINEAR,
			D3DX_FILTER_LINEAR,
			0,
			NULL,
			NULL,
			&pTexture);
		if (FAILED(hr))
		{
			m_strLastError = "Could not create ";
			m_strLastError += strTextureName;
			return E_FAIL;
		}
		m_vecCausticTextures.push_back(pTexture);
    }

	
	// Load the seafloor x file and extract its mesh
    m_pFloorMesh = new NVMesh();
    m_pFloorMesh->Create(m_pNVDevice, GetFilePath("seafloor.x"));
	m_pFloorMesh->SetFVF(m_pNVDevice, SEAFLOORVERTEX_FVF);
	m_pFloorMesh->SetVertexShader(m_dwSeaFloorShader);

    // Add some "hilliness" to the terrain
    LPDIRECT3DVERTEXBUFFER8 pVB;
    if( SUCCEEDED( m_pFloorMesh->GetSysMemMesh()->GetVertexBuffer( &pVB ) ) )
    {
        SeaFloorVertex* pVertices;
        DWORD   dwNumVertices = m_pFloorMesh->GetSysMemMesh()->GetNumVertices();

        pVB->Lock( 0, 0, (BYTE**)&pVertices, 0 );

        for( DWORD i=0; i<dwNumVertices; i++ )
		{
			pVertices[i].Position.y  += (rand()/(FLOAT)RAND_MAX);
			pVertices[i].Position.y  += (rand()/(FLOAT)RAND_MAX);
			pVertices[i].Position.y  += (rand()/(FLOAT)RAND_MAX);
			pVertices[i].Texture.x *= 10;
			pVertices[i].Texture.y *= 10;
		}

        pVB->Unlock();
        pVB->Release();
    }


	m_pFloorMesh->RestoreDeviceObjects(m_pNVDevice);

	m_pD3DDev->SetRenderState( D3DRS_FOGCOLOR, WATER_COLOR );
	m_pD3DDev->SetRenderState( D3DRS_FOGENABLE,      TRUE );
    m_pD3DDev->SetRenderState( D3DRS_FOGTABLEMODE,   D3DFOG_NONE );
    m_pD3DDev->SetRenderState( D3DRS_FOGVERTEXMODE,  D3DFOG_NONE );
    m_pD3DDev->SetRenderState( D3DRS_RANGEFOGENABLE, FALSE );

	m_pD3DDev->SetTextureStageState(0, D3DTSS_MINFILTER, D3DTEXF_LINEAR );
    m_pD3DDev->SetTextureStageState(0, D3DTSS_MAGFILTER, D3DTEXF_LINEAR );
	m_pD3DDev->SetTextureStageState(0, D3DTSS_MIPFILTER, D3DTEXF_LINEAR);

	m_pD3DDev->SetVertexShaderConstant(CV_ZERO, D3DXVECTOR4(0.0f,0.0f,0.0f,0.0f), 1);
	m_pD3DDev->SetVertexShaderConstant(CV_ONE, D3DXVECTOR4(1.0f,1.0f,1.0f,1.0f), 1);
	m_pD3DDev->SetVertexShaderConstant(CV_HALF, D3DXVECTOR4(0.5f,0.5f,0.5f,0.5f), 1);
	m_pD3DDev->SetVertexShaderConstant(CV_TEXTURESCALE, D3DXVECTOR4(0.5f, 0.05f, 0.0f, 1.0f), 1);
	
	D3DXVECTOR4 vFogData;
	vFogData.x = 1.0f;	// Fog Start
	vFogData.y = 50.0f; // Fog End
	vFogData.z = 1.0f / (vFogData.y - vFogData.x); // Fog range
	vFogData.w = 255.0f;
	m_pD3DDev->SetVertexShaderConstant(CV_FOGDATA, &vFogData.x, 1.0f);