graphics.cpp

骨骼动画....把魔兽模型解出的代码..

	if(FAILED(Direct3DDevice->BeginScene()))
	{
		Error.SetMessage("Unable to begin a new scene!");
		return FALSE;
	}

	SetShader();
	SetShaderConstants();

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Ends rendering
//+-----------------------------------------------------------------------------
VOID GRAPHICS::EndRender()
{
	Direct3DDevice->EndScene();

	CurrentGraphicsWindow->GetSwapChain()->Present(NULL, NULL, CurrentGraphicsWindow->GetWindow(), NULL, 0);
	CurrentGraphicsWindow = NULL;

	ScreenWidth = 0;
	ScreenHeight = 0;
	ScreenAspect = 0.0f;
}


//+-----------------------------------------------------------------------------
//| Renders some debug information
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderDebug()
{
	D3DXVECTOR3 Position;
	std::stringstream Stream;

	if(!Properties().ShowDebug) return;

	Position = Camera.GetTarget();

	Stream << "Width:     " << MainWindow.GetWidth() << "\n";
	Stream << "Height:    " << MainWindow.GetHeight() << "\n";
	Stream << "Pitch:     " << Camera.GetPitch() << "\n";
	Stream << "Yaw:       " << Camera.GetYaw() << "\n";
	Stream << "Distance:  " << Camera.GetDistance() << "\n";
	Stream << "X:         " << Position.x << "\n";
	Stream << "Y:         " << Position.y << "\n";
	Stream << "Z:         " << Position.z << "\n";
	Stream << "Particles: " << ParticleManager.GetNrOfParticles() << "\n";

	RenderText(Stream.str(), NULL, GRAPHICS_DEBUG_COLOR);
}


//+-----------------------------------------------------------------------------
//| Renders the coordinate system axises
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderAxises()
{
	BOOL XBeforeY;
	BOOL ZBeforeXY;
	FLOAT CameraPitch;
	FLOAT CameraYaw;
	FLOAT CameraDistance;
	D3DXVECTOR3 CameraPosition;
	D3DXVECTOR3 SourceVector;
	D3DXVECTOR3 TargetVectorX;
	D3DXVECTOR3 TargetVectorY;
	D3DXVECTOR3 TargetVectorZ;
	D3DXVECTOR3 ScreenVectorX;
	D3DXVECTOR3 ScreenVectorY;
	D3DXVECTOR3 ScreenVectorZ;
	D3DXVECTOR3 ScreenOffset;
	D3DXVECTOR3 FontOffset;
	D3DXVECTOR4 TempVector;
	D3DXMATRIX TempMatrix;
	D3DXMATRIX TempViewMatrix;
	D3DXMATRIX IdentityMatrix;
	D3DVIEWPORT9 ViewPort;

	if(!Properties().ShowAxises) return;

	D3DXMatrixIdentity(&WorldMatrix);
	D3DXMatrixIdentity(&IdentityMatrix);
	Direct3DDevice->GetViewport(&ViewPort);

	ScreenOffset = D3DXVECTOR3(-0.76f, -0.67f, 0.0f);
	FontOffset = D3DXVECTOR3(-5.0f, -5.0f, 0.0f);
	FontOffset.x += (ScreenOffset.x * ViewPort.Width / 2.0f);
	FontOffset.y -= (ScreenOffset.y * ViewPort.Height / 2.0f);

	CameraPitch = Camera.GetPitch();
	CameraYaw = Camera.GetYaw();
	CameraDistance = 10.0f;

	CameraPosition.x = CameraDistance * std::cos(CameraPitch) * std::cos(CameraYaw);
	CameraPosition.y = CameraDistance * std::cos(CameraPitch) * std::sin(CameraYaw);
	CameraPosition.z = CameraDistance * std::sin(CameraPitch);

	TempViewMatrix = ViewMatrix;
	SetCamera(CameraPosition, D3DXVECTOR3(0.0f, 0.0f, 0.0f));

	D3DXMatrixMultiply(&TempMatrix, &ViewMatrix, &ProjectionMatrix);

	D3DXVec3Transform(&TempVector, &D3DXVECTOR3(0.0f, 0.0f, 0.0f), &TempMatrix);
	SourceVector.x = ScreenOffset.x + TempVector.x;
	SourceVector.y = ScreenOffset.y + TempVector.y;
	SourceVector.z = 0.0f;

	D3DXVec3Transform(&TempVector, &D3DXVECTOR3(0.1f, 0.0f, 0.0f), &TempMatrix);
	TargetVectorX.x = ScreenOffset.x + TempVector.x;
	TargetVectorX.y = ScreenOffset.y + TempVector.y;
	TargetVectorX.z = 0.0f;

	D3DXVec3Transform(&TempVector, &D3DXVECTOR3(0.0f, 0.1f, 0.0f), &TempMatrix);
	TargetVectorY.x = ScreenOffset.x + TempVector.x;
	TargetVectorY.y = ScreenOffset.y + TempVector.y;
	TargetVectorY.z = 0.0f;

	D3DXVec3Transform(&TempVector, &D3DXVECTOR3(0.0f, 0.0f, 0.1f), &TempMatrix);
	TargetVectorZ.x = ScreenOffset.x + TempVector.x;
	TargetVectorZ.y = ScreenOffset.y + TempVector.y;
	TargetVectorZ.z = 0.0f;

	D3DXVec3Project(&ScreenVectorX, &D3DXVECTOR3(1.1f, 0.0f, 0.0f), &ViewPort, &ProjectionMatrix, &ViewMatrix, &WorldMatrix);
	D3DXVec3Project(&ScreenVectorY, &D3DXVECTOR3(0.0f, 1.1f, 0.0f), &ViewPort, &ProjectionMatrix, &ViewMatrix, &WorldMatrix);
	D3DXVec3Project(&ScreenVectorZ, &D3DXVECTOR3(0.0f, 0.0f, 1.1f), &ViewPort, &ProjectionMatrix, &ViewMatrix, &WorldMatrix);

	ScreenVectorX += FontOffset;
	ScreenVectorY += FontOffset;
	ScreenVectorZ += FontOffset;

	Direct3DDevice->SetTransform(D3DTS_WORLD, &IdentityMatrix);
	Direct3DDevice->SetTransform(D3DTS_VIEW, &IdentityMatrix);
	Direct3DDevice->SetTransform(D3DTS_PROJECTION, &IdentityMatrix);

	XBeforeY = ((CameraYaw > (D3DX_PI / 4.0f)) && (CameraYaw < (5.0f * D3DX_PI / 4.0f)));
	ZBeforeXY = (CameraPitch < 0.0f);

	PrepareForLines();

	if(ZBeforeXY)
	{
		RenderLine(SourceVector, TargetVectorZ, COLOR_AXIS_Z);
		RenderText("Z", static_cast<INT>(ScreenVectorZ.x), static_cast<INT>(ScreenVectorZ.y), COLOR_AXIS_Z);
	}

	if(XBeforeY)
	{
		RenderLine(SourceVector, TargetVectorX, COLOR_AXIS_X);
		RenderText("X", static_cast<INT>(ScreenVectorX.x), static_cast<INT>(ScreenVectorX.y), COLOR_AXIS_X);
	}

	RenderLine(SourceVector, TargetVectorY, COLOR_AXIS_Y);
	RenderText("Y", static_cast<INT>(ScreenVectorY.x), static_cast<INT>(ScreenVectorY.y), COLOR_AXIS_Y);

	if(!XBeforeY)
	{
		RenderLine(SourceVector, TargetVectorX, COLOR_AXIS_X);
		RenderText("X", static_cast<INT>(ScreenVectorX.x), static_cast<INT>(ScreenVectorX.y), COLOR_AXIS_X);
	}

	if(!ZBeforeXY)
	{
		RenderLine(SourceVector, TargetVectorZ, COLOR_AXIS_Z);
		RenderText("Z", static_cast<INT>(ScreenVectorZ.x), static_cast<INT>(ScreenVectorZ.y), COLOR_AXIS_Z);
	}

	ViewMatrix = TempViewMatrix;
	Direct3DDevice->SetTransform(D3DTS_WORLD, &WorldMatrix);
	Direct3DDevice->SetTransform(D3DTS_VIEW, &ViewMatrix);
	Direct3DDevice->SetTransform(D3DTS_PROJECTION, &ProjectionMatrix);
}


//+-----------------------------------------------------------------------------
//| Fills the screen in one color
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderFill(D3DCOLOR Color)
{
	Direct3DDevice->Clear(0, NULL, D3DCLEAR_TARGET, Color, 0.0f, 0);
}


//+-----------------------------------------------------------------------------
//| Renders a line
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderLine(CONST D3DXVECTOR3& From, CONST D3DXVECTOR3& To, D3DCOLOR Color)
{
	LINE_VERTEX* VertexPointer;

	if(FAILED(LineVertexBuffer->Lock(0, 0, reinterpret_cast<VOID**>(&VertexPointer), 0))) return;

	VertexPointer[0].Position = From;
	VertexPointer[0].Color = Color;
	VertexPointer[1].Position = To;
	VertexPointer[1].Color = Color;

	LineVertexBuffer->Unlock();

	Direct3DDevice->SetStreamSource(0, LineVertexBuffer, 0, sizeof(LINE_VERTEX));
	Direct3DDevice->DrawPrimitive(D3DPT_LINELIST, 0, 1);
}


//+-----------------------------------------------------------------------------
//| Renders a box
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderBox(CONST D3DXVECTOR3& Corner1, CONST D3DXVECTOR3& Corner2, D3DCOLOR Color)
{
	FLOAT Width;
	FLOAT Height;
	FLOAT Depth;
	LPD3DXMESH Mesh;
	D3DXVECTOR3 Center;
	DWORD OldCullMode;
	DWORD OldFillMode;

	Width = std::abs(Corner1.x - Corner2.x);
	Height = std::abs(Corner1.y - Corner2.y);
	Depth = std::abs(Corner1.z - Corner2.z);

	if(FAILED(D3DXCreateBox(Direct3DDevice, Width, Height, Depth, &Mesh, NULL))) return;

	Center = (Corner1 + Corner2) / 2;
	D3DXMatrixTranslation(&WorldMatrix, Center.x, Center.y, Center.z);
	SetWorldMatrix(WorldMatrix);

	Direct3DDevice->GetRenderState(D3DRS_CULLMODE, &OldCullMode);
	Direct3DDevice->GetRenderState(D3DRS_FILLMODE, &OldFillMode);

	Direct3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
	Direct3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

	Direct3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	Direct3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_BLENDFACTOR);
	Direct3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVBLENDFACTOR);
	Direct3DDevice->SetRenderState(D3DRS_BLENDFACTOR, Color);

	Mesh->DrawSubset(0);

	Direct3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	Direct3DDevice->SetRenderState(D3DRS_CULLMODE, OldCullMode);
	Direct3DDevice->SetRenderState(D3DRS_FILLMODE, OldFillMode);

	SAFE_RELEASE(Mesh);
}


//+-----------------------------------------------------------------------------
//| Renders a sphere
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderSphere(CONST D3DXVECTOR3& Center, FLOAT Radius, D3DCOLOR Color)
{
	INT Slices;
	INT Stacks;
	LPD3DXMESH Mesh;
	DWORD OldCullMode;
	DWORD OldFillMode;

	Slices = 8;
	Stacks = 6;

	if(FAILED(D3DXCreateSphere(Direct3DDevice, Radius, Slices, Stacks, &Mesh, NULL))) return;

	D3DXMatrixTranslation(&WorldMatrix, Center.x, Center.y, Center.z);
	SetWorldMatrix(WorldMatrix);

	Direct3DDevice->GetRenderState(D3DRS_CULLMODE, &OldCullMode);
	Direct3DDevice->GetRenderState(D3DRS_FILLMODE, &OldFillMode);

	Direct3DDevice->SetRenderState(D3DRS_CULLMODE, D3DCULL_CW);
	Direct3DDevice->SetRenderState(D3DRS_FILLMODE, D3DFILL_WIREFRAME);

	Direct3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, TRUE);
	Direct3DDevice->SetRenderState(D3DRS_SRCBLEND, D3DBLEND_BLENDFACTOR);
	Direct3DDevice->SetRenderState(D3DRS_DESTBLEND, D3DBLEND_INVBLENDFACTOR);
	Direct3DDevice->SetRenderState(D3DRS_BLENDFACTOR, Color);

	Mesh->DrawSubset(0);

	Direct3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	Direct3DDevice->SetRenderState(D3DRS_CULLMODE, OldCullMode);
	Direct3DDevice->SetRenderState(D3DRS_FILLMODE, OldFillMode);

	SAFE_RELEASE(Mesh);
}


//+-----------------------------------------------------------------------------
//| Renders a particle
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderParticle(D3DCOLOR Color, FLOAT Left, FLOAT Top, FLOAT Right, FLOAT Bottom)
{
	PARTICLE_VERTEX* VertexPointer;

	if(FAILED(ParticleVertexBuffer->Lock(0, 0, reinterpret_cast<VOID**>(&VertexPointer), 0))) return;

	VertexPointer[0].Color = Color;
	VertexPointer[0].TexturePosition = D3DXVECTOR2(Left, Top);
	VertexPointer[1].Color = Color;
	VertexPointer[1].TexturePosition = D3DXVECTOR2(Left, Bottom);
	VertexPointer[2].Color = Color;
	VertexPointer[2].TexturePosition = D3DXVECTOR2(Right, Top);
	VertexPointer[3].Color = Color;
	VertexPointer[3].TexturePosition = D3DXVECTOR2(Right, Bottom);

	ParticleVertexBuffer->Unlock();

	Direct3DDevice->SetFVF(PARTICLE_VERTEX::FORMAT);
	Direct3DDevice->SetStreamSource(0, ParticleVertexBuffer, 0, sizeof(PARTICLE_VERTEX));
	Direct3DDevice->DrawPrimitive(D3DPT_TRIANGLESTRIP, 0, 2);
}


//+-----------------------------------------------------------------------------
//| Renders the ground texture
//+-----------------------------------------------------------------------------
VOID GRAPHICS::RenderGroundTexture()
{
	FLOAT Scale;
	TEXTURE* Texture;

	if(!Properties().UseGroundTexture) return;

	TextureManager.Load(Properties().GroundTexture);
	Error.ClearMessage();

	Texture = TextureManager.GetTexture(Properties().GroundTexture);
	if(Texture == NULL) return;

	Scale = Properties().GroundTextureScale;
	D3DXMatrixScaling(&WorldMatrix, Scale, Scale, Scale);
	SetWorldMatrix(WorldMatrix);

	Graphics.SetShading(TRUE);
	Graphics.SetCulling(FALSE);

	Graphics.SetShader();
	Graphics.SetShaderConstants();

	Direct3DDevice->SetRenderState(D3DRS_ALPHABLENDENABLE, FALSE);
	Direct3DDevice->SetRenderState(D3DRS_ALPHATESTENABLE, FALSE);

	Direct3DDevice->SetRenderState(D3DRS_ZENABLE, TRUE);
	Direct3DDevice->SetRenderState(D3DRS_ZWRITEENABLE, TRUE);

	Direct3DDevice->SetTexture(0, Texture->GetTexture());
	Direct3DDevice->SetFVF(GROUND_VERTEX::FORMAT);