shader_twosided.cpp

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

	// Set default view:
	m_EyePos.x  =	  0.0f;
	m_EyePos.y	=   -10.0f;
	m_EyePos.z	=     0.0f;

	m_vLookAt.x = 0.0f;
	m_vLookAt.y = 0.0f;
	m_vLookAt.z = 0.0f;

	m_vUp.x =  0.0f;
	m_vUp.y =  0.0f;
	m_vUp.z = -1.0f;


	// Set world matrix to view from an angle
	D3DXMatrixIdentity(&m_matWorld);


	// Set field of view

	D3DXMatrixPerspectiveFovLH(&m_matProj, D3DXToRadian(55.0f),
								1.0f,
								0.1f, 500.0f);		// znear,far


	SetView();
}





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


void CShaderTwoSided::Keyboard( DWORD dwKey, UINT nFlags, bool bDown)
{

	float strafe_factor = 0.1f;
	float strafe_min    = 0.1f;

	UINT charcode;

	if( bDown )
	{

		switch( dwKey )
		{
		case 'T':
			// increase tesselation
			m_nVDiv ++;
			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case 'G':
			// decrease tesselation
			m_nVDiv --;
			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case 'H':
			// increase tesselation
			m_nHDiv ++;
			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case 'F':
			// decrease tesselation
			m_nHDiv --;
			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case '.':
		case '>':
			m_fTwist += 0.05f;

			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case ',':
		case '<':
			m_fTwist -= 0.05f;

			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case 'R':
			m_nHDiv = 6;
			m_nVDiv = 35;
			m_fTwist = 0.3f;
			m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
			m_pObj->GenerateNormals();
			break;

		case 'W':
			m_bWireframe = !m_bWireframe;
			m_dwEffectDirtyFlags |= EBEFFECT_DIRTY_PUBLICSTATE;
			break;

		case VK_UP :
		case VK_NUMPAD8 :
			m_EyePos.y +=max( strafe_min, fabs( m_EyePos.y * strafe_factor ));
			m_vLookAt.y += max( strafe_min, fabs( m_vLookAt.y * strafe_factor ));
			SetView();
			break;

		case VK_DOWN :
		case VK_NUMPAD2 :
			m_EyePos.y -=max( strafe_min, fabs( m_EyePos.y * strafe_factor ));
			m_vLookAt.y -= max( strafe_min, fabs( m_vLookAt.y * strafe_factor ));
			SetView();
			break;

		case VK_LEFT :
		case VK_NUMPAD4 :
			m_EyePos.x -=max( strafe_min, fabs( m_EyePos.x * strafe_factor ));
			m_vLookAt.x -= max( strafe_min, fabs( m_vLookAt.x * strafe_factor ));
			SetView();
			break;

		case VK_RIGHT :
		case VK_NUMPAD6 :
			m_EyePos.x += max( strafe_min, fabs( m_EyePos.x * strafe_factor ));
			m_vLookAt.x += max( strafe_min, fabs( m_vLookAt.x * strafe_factor ));
			SetView();
			break;

		case VK_NUMPAD9 :
		case VK_PRIOR :		// pageup
			m_EyePos.z += max( strafe_min, fabs( m_EyePos.z * strafe_factor ));
			m_vLookAt.z += max( strafe_min, fabs( m_vLookAt.z * strafe_factor ));
			SetView();
			break;

		case VK_NUMPAD3 :
		case VK_NEXT    :   // pagedown
			m_EyePos.z -= max( strafe_min, fabs( m_EyePos.z * strafe_factor ));
			m_vLookAt.z -= max( strafe_min, fabs( m_vLookAt.z * strafe_factor ));
			SetView();
			break;

		case VK_HOME :
		case VK_NUMPAD7 :
			SetDefaultView();
			break;

		default:

			charcode = MapVirtualKey( dwKey, 2 ); // VK to char code
			switch( charcode )
			{

			case '.':
			case '>':
				m_fTwist += 0.05f;

				m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
				m_pObj->GenerateNormals();
				break;

			case ',':
			case '<':
				m_fTwist -= 0.05f;

				m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
				m_pObj->GenerateNormals();
				break;

			case '[':
			case '{':
				m_fWidth -= 0.05f;
				m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
				m_pObj->GenerateNormals();
				break;

			case ']':
			case '}':
				m_fWidth += 0.05f;
				m_pObj->InitSpiral( m_fWidth, 10.0f, m_nHDiv, m_nVDiv, m_fTwist );
				m_pObj->GenerateNormals();
				break;
			};

			break;
		}
	}
}

  
HRESULT CShaderTwoSided::Tick(EBTimer* pTimer)
{
	HRESULT hr = S_OK;
	D3DXMATRIX matWorld, matInvWorld;
	D3DXMATRIX matTemp;

	D3DXVECTOR4  eyeObjSpc, lightObjSpc;	   // eye and light positions in object space

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


	if( m_bWireframe )
	{
		m_pD3DDev->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);
	}
	else
	{
		m_pD3DDev->SetRenderState(D3DRS_FILLMODE, D3DFILL_SOLID );
	}


	// Increase rotation
	m_fAngle = 9.0f * ((float)timeGetTime())/1000.0f;

	// Set light position:
	float lightr = 2.5f;
	float lang  =  m_fAngle * 8.0f;

	m_LightPos.x  = lightr * (float)sin( D3DXToRadian( lang ) );
	m_LightPos.y  = lightr * (float)cos( D3DXToRadian( lang ) );
	m_LightPos.z  = 4.0f   * (float)sin( D3DXToRadian( lang * 0.5f ) );



	// Uncomment for no object rotation
	//	m_fAngle = 90.0f;


	// World matrix for rendering twisted sheet object
	D3DXVECTOR3 vRotation( 0.0f, 0.0f, 1.0f);
	D3DXMatrixRotationAxis( &matWorld, &vRotation, D3DXToRadian(m_fAngle));

	// compute inverse of rotation matrix
	D3DXMatrixTranspose( &matInvWorld, &matWorld );

	// Transform light and cam pos to object space and set vshader constants

	D3DXVec3Transform( &lightObjSpc, &m_LightPos, &matInvWorld );
	D3DXVec3Transform( &eyeObjSpc, &m_EyePos, &matInvWorld );

	// Set vshader constants
	m_pD3DDev->SetVertexShaderConstant( CV_LIGHT_POS_OSPACE, (void*)&lightObjSpc.x, 1 );
	m_pD3DDev->SetVertexShaderConstant( CV_EYE_POS_OSPACE,   (void*)&eyeObjSpc.x,   1 );



	// Set vshader constant to world * view * proj matrix:

    D3DXMatrixMultiply( &matTemp, &matWorld, &m_matView );
	D3DXMatrixMultiply( &matTemp, &matTemp, &m_matProj );

	// Set 4 constants starting with CV_WORLDVIEWPROJ_0
	D3DXMatrixTranspose( &matTemp, &matTemp );
	m_pD3DDev->SetVertexShaderConstant(CV_WORLDVIEWPROJ_0, &matTemp(0, 0), 4);



	m_pD3DDev->SetVertexShader(m_dwTwoSidedVShader);
	m_pD3DDev->SetPixelShader(m_dwTwoSidedPixelShader);

	m_pD3DDev->SetTexture(0,(LPDIRECT3DBASETEXTURE8)m_pDecalTexture);


	// Draw the twisted strip object
	if( m_pObj != NULL )
	{
		m_pObj->Draw( m_pD3DDev );
	}



	// Set world matrix to light position & render light
	//  stand-in object:

	D3DXMatrixTranslation( &matWorld, m_LightPos.x, m_LightPos.y, m_LightPos.z );

	// Setup the transforms
	m_pD3DDev->SetTransform(D3DTS_PROJECTION,	&m_matProj  );
	m_pD3DDev->SetTransform(D3DTS_VIEW,			&m_matView  );
	m_pD3DDev->SetTransform(D3DTS_WORLD,		&matWorld );

	m_pD3DDev->SetVertexShader( SOBJVERT_FVF			    );
	m_pD3DDev->SetPixelShader(  m_dwTwoSidedNoLightShader	);


	m_pD3DDev->SetTexture(0,(LPDIRECT3DBASETEXTURE8) m_pLightObjTexture );

	// Draw the light object
	if( m_pObjLight != NULL )
	{
		m_pObjLight->Draw( m_pD3DDev );
	}


	return hr;
}


HRESULT CShaderTwoSided::ConfirmDevice(D3DCAPS8* pCaps, DWORD dwBehavior, D3DFORMAT Format)
{
	if (!(pCaps->TextureCaps & D3DPTEXTURECAPS_PROJECTED))
	{
		m_strLastError = "Device does not support 3 element texture coordinates!";
		return E_FAIL;
	}

	if (!(pCaps->MaxTextureBlendStages >= 2))
	{
		m_strLastError = "Not enough texture blend stages!";
		return E_FAIL;
	}

	if(D3DSHADER_VERSION_MAJOR(pCaps->PixelShaderVersion) < 1)
	{
		m_strLastError = "Device does not support pixel shaders!";
		return E_FAIL;
	}

	return S_OK;
}