shader_dot3_point.cpp

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

	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_point_atten.vso"), &Declaration[0], 0, SHADERTYPE_VERTEX, &m_dwDot3PointLightAttenuationShader);
	if (FAILED(hr))
		return hr;

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

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

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

	LPDIRECT3DTEXTURE8 pHeightMap;
	hr = D3DXCreateTextureFromFileEx(m_pD3DDev, 
		GetFilePath("bump_map_nvidia.dds").c_str(),
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		0,
		0,
		D3DFMT_A8R8G8B8,
		D3DPOOL_MANAGED,
		D3DX_FILTER_LINEAR,
		D3DX_FILTER_LINEAR,
		0,
		NULL,
		NULL,
		&pHeightMap);
	if (FAILED(hr))
	{
		m_strLastError = "Could not create brickb.dds";
		return hr;
	}
	m_pBumpMap = NVTexture2::CreateNormalMap(m_pD3DDev, pHeightMap, D3DFMT_A8R8G8B8);
	SAFE_RELEASE(pHeightMap);

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

	hr = D3DXCreateTextureFromFileEx(m_pD3DDev, 
		GetFilePath("attenuate2D.tga").c_str(),
		D3DX_DEFAULT,
		D3DX_DEFAULT,
		1,
		0,
		D3DFMT_A8R8G8B8,
		D3DPOOL_MANAGED,
		D3DX_FILTER_LINEAR,
		D3DX_FILTER_LINEAR,
		0,
		NULL,
		NULL,
		&m_pAttenuate2D);
	if (FAILED(hr))
	{
		m_strLastError = "Could not create attenuate2D.tga";
		return hr;
	}

	FixAlpha((LPDIRECT3DTEXTURE8)m_pAttenuate2D);

	m_pNormalizationCubeMap = NVTexture2::CreateNormalizationCubeMap(m_pD3DDev, 256);
	if (m_pNormalizationCubeMap == NULL)
	{
		m_strLastError = "Could not create cube normalization map!";
		return E_FAIL;
	}

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

	D3DXVECTOR4 vecLightRange(1.0f / 1.4f, 0.0f, 0.0f, 0.0f);
	m_pD3DDev->SetVertexShaderConstant(CV_ONE_OVER_LIGHT_RANGE, (void*)&vecLightRange.x, 1);

	// Camera stuff
	D3DXMATRIX matProj;
	D3DXMATRIX matView;

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

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

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

	CreateBasisVectors(m_pSphereVertexBuffer, m_pSphereIndexBuffer);

	// Point at the vertex data
	hr = m_pD3DDev->SetStreamSource(0, m_pSphereVertexBuffer, sizeof(Dot3Vertex));
	if (FAILED(hr))
	{
		m_strLastError = "Could not set VB source";
		return hr;
	}
	
	// Point at the index data
	hr = m_pD3DDev->SetIndices(m_pSphereIndexBuffer, 0);
	if (FAILED(hr))
	{
		m_strLastError = "Could not set Index source";
		return hr;
	}

	for (int i = 0; i < NUM_DOT3_POINTLIGHTS; i++)
	{
		m_LightColor[i] = D3DXVECTOR4(1.0f, 1.0f, 1.0f, 1.0f);
	}	

	return S_OK;

}

HRESULT CShaderDot3Point::Free()
{
	SAFE_DELETE(m_pLightMesh);
	SAFE_RELEASE(m_pSphereVertexBuffer);
	SAFE_RELEASE(m_pSphereIndexBuffer);
		
	SAFE_DELETE(m_pNVDevice);
	SAFE_RELEASE(m_pBaseTexture);
	SAFE_RELEASE(m_pNormalizationCubeMap);
	SAFE_RELEASE(m_pAttenuate2D);
	SAFE_RELEASE(m_pBumpMap);
	SAFE_DELETE(m_pUI);
	if (m_pD3DDev)
	{
		m_pD3DDev->DeleteVertexShader(m_dwDot3PointLightAttenuationShader);
		m_pD3DDev->DeleteVertexShader(m_dwDot3PointLightBumpShader);
		m_pD3DDev->DeleteVertexShader(m_dwDot3DirectionalLightBumpShader);
		m_pD3DDev->DeleteVertexShader(m_dwLightShader);
		m_pD3DDev->DeleteVertexShader(m_dwTransformShader);
		SAFE_RELEASE(m_pD3DDev);
	}
	
	return S_OK;
}

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

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

	D3DXMATRIX matWorld = m_pNVDevice->GetWorldTransform();
	D3DXMATRIX matProj = m_pNVDevice->GetProjectionTransform();
	D3DXMATRIX matView = m_pNVDevice->GetViewTransform();

	D3DXMatrixMultiply(&matTemp, &matWorld, &matView);
	D3DXMatrixMultiply(&matWorldViewProj, &matTemp, &matProj);
	D3DXMatrixMultiply(&matWorldView, &matWorld, &matView);
	
	// Create a 3x3 invertse of the worldview for the normal transformation (we transpose it as we load it into
	// the constant store)
	D3DXMatrixInverse(&matWorldViewIT, NULL, &matWorldView);
		
	// Projection to clip space
	D3DXMatrixTranspose(&matWorldViewProj, &matWorldViewProj);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWPROJ_0, &matWorldViewProj(0, 0), 4);
	D3DXMatrixTranspose(&matWorldViewProj, &matWorldViewProj);

	// Transform to eye space
	D3DXMatrixTranspose(&matWorldView, &matWorldView);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEW_0, &matWorldView(0, 0), 4);
	D3DXMatrixTranspose(&matWorldView, &matWorldView);

	// Transform to world space
	D3DXMatrixTranspose(&matWorld, &matWorld);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLD_0, &matWorld(0, 0), 4);
	D3DXMatrixTranspose(&matWorld, &matWorld);

	// Transform for normals
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWIT_0, &matWorldViewIT(0, 0), 1);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWIT_1, &matWorldViewIT(1, 0), 1);
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWIT_2, &matWorldViewIT(2, 0), 1);

	return S_OK;

}

// Draw the actual light so we can see where it's pointing.
HRESULT CShaderDot3Point::DrawPointLightObjects()
{
	D3DXMATRIX matWorld;
	D3DXMATRIX matTranslate;
	D3DXMATRIX matScale;
	D3DXMATRIX matTranslatePosition;

	const NVBounds* pBounds = m_pLightMesh->GetBounds();
	D3DXMatrixIdentity(&matWorld);

	// Translate to the middle
	D3DXMatrixTranslation(&matTranslate, -pBounds->m_vecCenter.x, -pBounds->m_vecCenter.y, -pBounds->m_vecCenter.z);
	
	float fLightScale = 0.1f; 
	D3DXMatrixScaling(&matScale, fLightScale / pBounds->m_fRadius, fLightScale / pBounds->m_fRadius, fLightScale / pBounds->m_fRadius);

	m_pD3DDev->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	m_pD3DDev->SetTextureStageState(0, D3DTSS_COLOROP, D3DTOP_DISABLE);
	m_pD3DDev->SetTextureStageState(1, D3DTSS_COLOROP, D3DTOP_DISABLE);

	for (int i = 0 ; i < NUM_DOT3_POINTLIGHTS; i++)
	{
		// vecLightPosition translatino
		D3DXMatrixTranslation(&matTranslatePosition, m_LightPosition[i].x, m_LightPosition[i].y, m_LightPosition[i].z);
		
		matWorld = matTranslate * matScale * matTranslatePosition;
		
		m_pD3DDev->SetVertexShaderConstant(CV_LIGHT_COLOR, &m_LightColor[i].x, 1);

		m_pNVDevice->SetWorldTransform(&matWorld);
		SetTransform();

		m_pLightMesh->Render(m_pNVDevice);
	}

	return S_OK;
}

HRESULT CShaderDot3Point::Tick(EBTimer* pTimer)
{
	HRESULT hr = S_OK;
	D3DXMATRIX matWorld;
	D3DXMATRIX matView = m_pNVDevice->GetViewTransform();
	D3DXMATRIX matTemp;

	// Clear to grey
	hr = m_pD3DDev->Clear(0, NULL, D3DCLEAR_TARGET|D3DCLEAR_ZBUFFER, D3DCOLOR_XRGB( 0xAA, 0xAA, 0xAA ), 1.0, 0);

	m_pD3DDev->SetRenderState(D3DRS_FILLMODE, m_bWireframe ? D3DFILL_WIREFRAME : D3DFILL_SOLID);

	// Increase rotation
	if (!m_bPause)
	{
		m_fAngle += 0.1f;
		m_fDuration = pTimer->GetDuration();
	}

	// World
	D3DXMatrixMultiply( &matWorld, &m_pUI->GetRotationMatrix(), &m_pUI->GetTranslationMatrix() );
			
	// Load transform data.
	m_pNVDevice->SetWorldTransform(&matWorld);
	SetTransform();

	// Create the light position vector.
	D3DXVECTOR3 vecLightPosition;
	float fLightDistance = 1.2f;
	for (int i = 0; i < NUM_DOT3_POINTLIGHTS; i++)
	{
		switch(i)
		{
			case 0:
				m_LightPosition[i].x = (fLightDistance / 2.0f) * cos( D3DXToRadian(m_fAngle));
				m_LightPosition[i].y = (fLightDistance / 2.0f) * sin( D3DXToRadian(m_fAngle));
				m_LightPosition[i].z = (sin(m_fDuration * 2.0f) * 0.3f) + -fLightDistance;
				break;
			case 1:
				fLightDistance += 0.1f;
				m_LightPosition[i].x = (fLightDistance / 2.0f) * sin( D3DXToRadian(m_fAngle));
				m_LightPosition[i].y = (fLightDistance / 2.0f) * cos( D3DXToRadian(m_fAngle));
				m_LightPosition[i].z = (sin(m_fDuration * 2.0f) * 0.3f) + -fLightDistance;
				break;
		}

		m_LightPosition[i].x += matWorld._41;
		m_LightPosition[i].y += matWorld._42;
		m_LightPosition[i].z += matWorld._43;
	}	

	// Do the rendering
	DrawPoints();

	// Draw the light shape
	DrawPointLightObjects();



	return hr;
}

HRESULT CShaderDot3Point::DrawPoints()