shader_dot3_directional.cpp

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

/*********************************************************************NVMH2****
Path:  C:\Dev\devrel\Nv_sdk_4\Dx8\NVEffectsBrowser\Effects\Dot3Bump_Dynamic
File:  shader_Dot3_Directional.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 "nvdevice.h"
#include "nvmesh.h"

#include "shader_Dot3_Directional.h"
#include "Constants.h"
#include "SimpleObject8.h"

#include "CA_WaterWaves.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)
{
	switch(EffectNum)
	{
		case 0:
			return new CShaderDot3Directional();
		default:
			return NULL;
	}
}

}


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

void CShaderDot3Directional::UpdateProperties()
{
	EBEffect::UpdateProperties();
	EBEnumProperty* pEnumProp = new EBEnumProperty("Display Options", OBJECT_MEMBER(m_eDisplayOption), EBTYPE_DWORD_PROP);
	
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show Bump Map", (DWORD)DISPLAY_BUMPMAP, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show Texture Space Light Vector", (DWORD)DISPLAY_LIGHTVECTOR, EBTYPE_DWORD_PROP));
	pEnumProp->AddEnumerant(new EBEnumValue(pEnumProp, "Show Per-pixel Bumpmapping", (DWORD)DISPLAY_RESULT, EBTYPE_DWORD_PROP));
	AddProperty(pEnumProp);


	AddProperty(new EBProperty("Wireframe", OBJECT_MEMBER(m_bWireframe), EBTYPE_BOOL_PROP));
	AddProperty(new EBProperty("Pause lights", OBJECT_MEMBER(m_bPause), EBTYPE_BOOL_PROP));

	//////////////////////////////////////////////////////////////////////////
	// Add vertex & pixel shader display to the tabbed text boxes:
	// Vertex shaders
	// m_pVertexShaderEnum & PixelShaderEnum are part of base effect class =)
	//
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Texture Space Calculation",
										GetFilePath("dot3_directional.nvv"), EBTYPE_STRING_PROP));
	m_pVertexShaderEnum->AddEnumerant(new EBEnumValue(m_pVertexShaderEnum, "Neighbor Sampling Setup",
										GetFilePath("TexCoord_4_Offset.nvv"), EBTYPE_STRING_PROP));

	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Force: Step 1",
										GetFilePath("NeighborForceCalc.nvp"), EBTYPE_STRING_PROP ));
	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Force: Step 2",
										GetFilePath("NeighborForceCalc2_X2.nvp"), EBTYPE_STRING_PROP ));

	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Apply Force",
										GetFilePath("ApplyForceShader.nvp"), EBTYPE_STRING_PROP ));
	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Apply Velocity",
										GetFilePath("ApplyVelocityShader.nvp"), EBTYPE_STRING_PROP ));
	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Smooth",
										GetFilePath("EqualWeightCombine_PostMult.nvp"), EBTYPE_STRING_PROP ));

	m_pPixelShaderEnum->AddEnumerant( new EBEnumValue(m_pPixelShaderEnum, "Gray to NormalMap",
										GetFilePath("NormalMapCreate2_Scale.nvp"), EBTYPE_STRING_PROP ));

    string aboutText = "file://";
    aboutText += GetFilePath("NVEffectsExplained.htm");
    aboutText += "#DynamicDot3BumpMapping";
	SetAboutInfo( NULL, _T("Dynamic Dot3 Bump Directional"), _T(aboutText.c_str()));
	SetAboutInfo( NULL, _T("Developer Relations"), _T("http://www.nvidia.com/developer"));
	SetAboutInfo( NULL, _T("NVIDIA Corporation"), _T("http://www.nvidia.com"));
	SetAboutInfo( _T("Date"), _T("May 2001"));
}


CShaderDot3Directional::CShaderDot3Directional()
:	m_eDisplayOption(DISPLAY_RESULT),
	m_pSphereVertexBuffer(NULL),
	m_pSphereIndexBuffer(NULL),
	m_fAngle(0.0f),
	m_pLightMesh(NULL),
	m_pNVDevice(NULL),
	m_dwLightShader(0),
	m_dwDot3Shader(0),
	m_pUI(NULL),
	m_bWireframe(false),
	m_bPause(false)
{
	m_strEffectLocation = "Effects\\Bump Mapping";
	m_strEffectName = "Dynamic Dot3 Bump Directional";		// A string holding the name of the effect
	m_strEffectPixelShader = "";
	m_strEffectVertexShader = GetFilePath("dot3_directional.nvv");
	m_strEffectVersion = "1.0";
	
	m_pCA_Water = NULL;

}

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

HRESULT CShaderDot3Directional::GenerateSphere(D3DXVECTOR3& vCenter, FLOAT fRadius,
											   WORD wNumRings, WORD wNumSections,
											   FLOAT scale_x, FLOAT scale_y, FLOAT scale_z)
{


	SimpleObject8	* pObj = new SimpleObject8();
	assert( pObj != NULL );

	pObj->InitSphere( fRadius, wNumRings, wNumSections );


	////////////////////////////////////////////////
	// Make vertex buffer & index buffer from it

	HRESULT hr;
	D3DXVECTOR3 vPoint;
	DWORD i;

	SAFE_RELEASE(m_pSphereVertexBuffer);
	SAFE_RELEASE(m_pSphereIndexBuffer);

	assert( pObj->m_PrimType == D3DPT_TRIANGLELIST );


	DWORD	wNumTriangles	= pObj->m_wNumInd / 3;
    DWORD   dwNumIndices	= pObj->m_wNumInd;
    DWORD   dwNumVertices	= pObj->m_wNumVerts;

	m_dwNumVertices = dwNumVertices;
	m_dwNumIndices = wNumTriangles * 3;
	m_dwNumFaces = wNumTriangles;	


	hr = m_pD3DDev->CreateVertexBuffer(dwNumVertices * sizeof(Dot3Vertex), 0, 0, D3DPOOL_DEFAULT, &m_pSphereVertexBuffer);
	ASSERT_IF_FAILED(hr);
	if (FAILED(hr))
		return hr;

	hr = m_pD3DDev->CreateIndexBuffer(3 * wNumTriangles * sizeof(WORD), 0, D3DFMT_INDEX16, D3DPOOL_DEFAULT, &m_pSphereIndexBuffer);
	ASSERT_IF_FAILED(hr);
	if (FAILED(hr))
		return hr;


	Dot3Vertex* pVertices;
	WORD* pIndices;
	
	m_pSphereVertexBuffer->Lock(0, 0, (BYTE**)&pVertices, 0);
	m_pSphereIndexBuffer->Lock(0, 0, (BYTE**)&pIndices, 0);

	
	float x,y,z, nx, ny, nz, u, v;

	// copy positions into VB
    for( i = 0; i < dwNumVertices; i++ )
    {
		x = scale_x * pObj->m_pVertices[i].pos.x	+ vCenter.x;
		y = scale_y * pObj->m_pVertices[i].pos.y	+ vCenter.y;
		z = scale_z * pObj->m_pVertices[i].pos.z	+ vCenter.z;

		nx = pObj->m_pVertices[i].nrm.x;
		ny = pObj->m_pVertices[i].nrm.y;
		nz = pObj->m_pVertices[i].nrm.z;

		u = pObj->m_pVertices[i].t0.x * 2.0f;
		v = pObj->m_pVertices[i].t0.y * 2.0f + 0.5f;

		pVertices[i] = Dot3Vertex(	D3DXVECTOR3( x, y, z ),
									D3DXVECTOR3( nx, ny, nz ),
									D3DXVECTOR2( u, v ) );
	}



    // Generate triangle index buffer from simple object's indices

    for( i = 0; i < dwNumIndices; i++ )
    {
        pIndices[i] = pObj->m_pIndices[i];
	}


	// All done - unlock the buffers:

	hr = m_pSphereVertexBuffer->Unlock();
	ASSERT_IF_FAILED(hr);

	hr = m_pSphereIndexBuffer->Unlock();
	ASSERT_IF_FAILED(hr);


	// Free the SimpleObject

	delete( pObj );
	pObj = NULL;


	// Compute the tangent space

	hr = CreateBasisVectors( m_pSphereVertexBuffer, m_pSphereIndexBuffer);
	ASSERT_IF_FAILED(hr);


    return S_OK;
}


HRESULT CShaderDot3Directional::Initialize(IDirect3DDevice8* pDev)
{
	HRESULT hr;
	vector<DWORD> Declaration;

	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);

	m_pNVDevice = new NVDot3DirectionalDevice(pDev, this);


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


	m_pCA_Water = new CA_Water();
	assert( m_pCA_Water != NULL );

	m_pCA_Water->Initialize( pDev );

	m_pCA_Water->SetNormalMapSTScale( 0.3f );

	m_pCA_Water->SetBlurDistance( 0.50f );
	m_pCA_Water->SetEqRestoreFac( 0.05f );
	m_pCA_Water->SetVelocityApplyFac( 0.4998f );
	m_pCA_Water->SetBlendFac( 0.2499f );


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


	m_pLightMesh = new NVMesh();
	hr = m_pLightMesh->Create(m_pNVDevice, GetFilePath("arrow.x"));
	if (FAILED(hr))
	{
		m_strLastError = "Could not load arrow.x";
		return hr;
	}
	m_pLightMesh->SetFVF(m_pNVDevice, D3DFVF_NORMAL | D3DFVF_XYZ | D3DFVF_TEX1);


	hr = GenerateSphere(D3DXVECTOR3(0.0f, 0.0f, 0.0f), 1.2f, 20, 20, 1.0f, 1.0f, 1.0f);
//	hr = GenerateSphere(D3DXVECTOR3(0.0f, 0.0f, 0.0f), 1.3f, 2, 4, 1.0f, 1.0f, 1.0f);
	
	if (FAILED(hr))
	{
		m_strLastError = "Could not generate sphere";
		return hr;
	}

	// Create the shaders
	Declaration.clear();
	Declaration.push_back(D3DVSD_STREAM(0));
	Declaration.push_back(D3DVSD_REG(0, D3DVSDT_FLOAT3)); // Pos
	Declaration.push_back(D3DVSD_REG(1, D3DVSDT_FLOAT3)); // Normal
	Declaration.push_back(D3DVSD_REG(2, D3DVSDT_FLOAT2)); // Texture
	Declaration.push_back(D3DVSD_END());
	hr = LoadAndCreateShader(GetFilePath("dot3_lightobject.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwLightShader);
	if (FAILED(hr))
		return hr;

	m_pLightMesh->SetVertexShader(m_dwLightShader);

	Declaration.clear();
	Declaration.push_back(D3DVSD_STREAM(0));
	Declaration.push_back(D3DVSD_REG(0, D3DVSDT_FLOAT3)); // Position
	Declaration.push_back(D3DVSD_REG(1, D3DVSDT_FLOAT3)); // Normal
	Declaration.push_back(D3DVSD_REG(2, D3DVSDT_FLOAT3)); // Diffuse
	Declaration.push_back(D3DVSD_REG(3, D3DVSDT_FLOAT2)); // Texture
	Declaration.push_back(D3DVSD_REG(5, D3DVSDT_FLOAT3)); // S
	Declaration.push_back(D3DVSD_REG(6, D3DVSDT_FLOAT3)); // T
	Declaration.push_back(D3DVSD_REG(4, D3DVSDT_FLOAT3)); // SxT
	Declaration.push_back(D3DVSD_END());

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


	// Setup constants
	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);

	// Camera stuff
	D3DXMATRIX matProj;
	D3DXMATRIX matView;

	D3DXVECTOR3 vEyePt = D3DXVECTOR3( 0.0f, -3.0f, 0 );
	D3DXVECTOR3 vLookatPt = D3DXVECTOR3( 0.0f, 0.0f, 0.0f );
	D3DXVECTOR3 vUp = D3DXVECTOR3( 0.0f, 0.0f, -1.0f );

	// View
	D3DXMatrixLookAtLH(&matView, &vEyePt, &vLookatPt, &vUp);


	// update mouseUI's orientation
	m_pUI->SetViewMode( MouseUI::VM_CAMERA_AWARE );
	m_pUI->SetControlOrientationMatrix( matView );

	m_pUI->SetTranslationalSensitivityFactor( 0.25f );


	// Projection
	D3DXMatrixPerspectiveFovLH(&matProj, D3DXToRadian(60.0f), 1.0f, 0.1f, 50.0f);

	m_pNVDevice->SetViewTransform(&matView);
	m_pNVDevice->SetProjectionTransform(&matProj);

	m_pD3DDev->SetRenderState(D3DRS_SPECULARENABLE, FALSE);


	if (m_pLightMesh)
		m_pLightMesh->RestoreDeviceObjects(m_pNVDevice);
	
	return S_OK;

}

HRESULT CShaderDot3Directional::Free()
{
	SAFE_DELETE(m_pLightMesh);
	SAFE_RELEASE(m_pSphereVertexBuffer);
	SAFE_RELEASE(m_pSphereIndexBuffer);
	SAFE_DELETE(m_pNVDevice);
	SAFE_DELETE(m_pUI);

	SAFE_DELETE( m_pCA_Water );

	if (m_pD3DDev)
	{
		if (m_dwDot3Shader)
			m_pD3DDev->DeleteVertexShader(m_dwDot3Shader);
		if (m_dwLightShader)
			m_pD3DDev->DeleteVertexShader(m_dwLightShader);
		SAFE_RELEASE(m_pD3DDev);
	}
	
	return S_OK;
}

HRESULT CShaderDot3Directional::Start()
{
	m_fAngle = 0.0f;
	return S_OK;
}

  
HRESULT CShaderDot3Directional::SetTransform()
{
	D3DXMATRIX matTemp;
	D3DXMATRIX matWorldViewProj;
	D3DXMATRIX matWorldView;
	D3DXMATRIX matWorldViewIT;
	D3DXMATRIX matWorldInverse;

	D3DXMATRIX matWorld = m_pNVDevice->GetWorldTransform();