//========= Copyright © 1996-2005, Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "uigeometry.h"
#include "materialsystem/imaterialsystem.h"
#include "mathlib/vector.h"
#include "gamegraphic.h"
#include "graphicgroup.h"


// memdbgon must be the last include file in a .cpp file!!!
#include "tier0/memdbgon.h"


//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
CGeometry::CGeometry()
{
	m_Center.x = 0;
	m_Center.y = 0;

	m_Scale.x = 1;
	m_Scale.y = 1;

	m_Rotation = 0;

	m_Color.r = 255;
	m_Color.g = 255;
	m_Color.b = 255;
	m_Color.a = 255;

	m_TopColor.r = 255;
	m_TopColor.g = 255;
	m_TopColor.b = 255;
	m_TopColor.a = 255;

	m_BottomColor.r = 255;
	m_BottomColor.g = 255;
	m_BottomColor.b = 255;
	m_BottomColor.a = 255;

	m_bHorizontalGradient = false;

	m_SheetSequenceNumber = 0;
	m_AnimationRate = 1;

	m_Sublayer = -1;
	m_bMaintainAspectRatio = true;
	m_bVisible = true;

	m_AnimStartTime = DMETIME_ZERO;
	m_bAnimate = false;

	m_bDirtyExtents = false;
}

//-----------------------------------------------------------------------------
// Rendering helper
// Calculate a matrix that will transform the points of the geometry, which are
// currently relative to the center, into screen coords.
//-----------------------------------------------------------------------------
void CGeometry::UpdateRenderTransforms( const StageRenderInfo_t &stageRenderInfo, const CGraphicGroup *pGroup )
{
	Assert( pGroup );
	if ( !pGroup->IsStageGroup() )
	{
		if ( pGroup->GetVisible() == false )
		{
			Assert( m_bVisible == pGroup->GetVisible() );
		}		
	}
	
	if ( !m_bVisible )
		return;


	// Update positions relative to the center, texture coords, and vertex colors
	// If the group maintains aspect ratio it will already have handled this in its transform update.
	Vector2D center;
	bool bUseMaintainedMatrix = m_bMaintainAspectRatio && !pGroup->MaintainAspectRatio();
	if ( bUseMaintainedMatrix )
	{
		// If this is the case we transform the center to screen coords first.
		// Then take into account any size scaling in the scalemat
		// Note this is not accounting for groups or rotations.
		matrix3x4_t screenScalemat;
		SetScaleMatrix( stageRenderInfo.parentScale.x, stageRenderInfo.parentScale.y, 1, screenScalemat );
		Vector centerVec( m_Center.x, m_Center.y, 0 );
		Vector centerInScreen;
		VectorTransform( centerVec, screenScalemat, centerInScreen );

		// Remove the uniform scale component from the center because it will come back in GetRenderTransform()
		float scaleToUse;
		if ( stageRenderInfo.parentScale.x > stageRenderInfo.parentScale.y )
		{
			scaleToUse = stageRenderInfo.parentScale.y;
		}
		else
		{
			scaleToUse = stageRenderInfo.parentScale.x;
		}
		SetScaleMatrix( 1/scaleToUse, 1/scaleToUse, 1, screenScalemat );
		Vector tempCenter;
		VectorTransform( centerInScreen, screenScalemat, tempCenter );
		center.x = tempCenter.x;
		center.y = tempCenter.y;

		/* old version.
		// If this is the case we transform the center to screen coords first.
		// Then take into account any size scaling in the scalemat
		matrix3x4_t screenScalemat;
		SetScaleMatrix( stageRenderInfo.parentScale.x, stageRenderInfo.parentScale.y, 1, screenScalemat );
		Vector centerVec( m_Center.x, m_Center.y, 0 );
		Vector centerInScreen;
		VectorTransform( centerVec, screenScalemat, centerInScreen );
		center.x = centerInScreen.x;
		center.y = centerInScreen.y;
		*/
	}
	else
	{
		center = m_Center;
	}

	matrix3x4_t transmat;
	Vector position( center.x, center.y, 0 );
	SetIdentityMatrix( transmat );
	PositionMatrix( position, transmat );

	matrix3x4_t scalemat;
	SetScaleMatrix( m_Scale.x, m_Scale.y, 1, scalemat );

	matrix3x4_t rotmat;
	Vector axis( 0, 0, 1 );
	MatrixBuildRotationAboutAxis( axis, m_Rotation, rotmat );

	matrix3x4_t temp;
	MatrixMultiply( rotmat, scalemat, temp );
	matrix3x4_t rawToLocal;
	MatrixMultiply( transmat, temp, rawToLocal );

	matrix3x4_t groupToScreen;
	// Use the matrix that doesn't contain any scale changes if we should
	pGroup->GetRenderTransform( groupToScreen, bUseMaintainedMatrix );
	MatrixMultiply( groupToScreen, rawToLocal, m_RenderToScreen );

	if ( m_bDirtyExtents )
	{
		CalculateExtentsMatrix( stageRenderInfo, pGroup );
	}
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
void CGeometry::UpdateRenderData( CUtlVector< RenderGeometryList_t > &renderGeometryLists, int firstListIndex )
{
	if ( !m_bVisible )
		return;

	int i = renderGeometryLists[firstListIndex].AddToTail();
	CRenderGeometry &renderGeometry = renderGeometryLists[firstListIndex][i];

	// Now transform our array of positions into local graphic coord system.
	int nCount = m_RelativePositions.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		// Position
		Vector relativePosition( m_RelativePositions[i].x, m_RelativePositions[i].y, 0 );
		Vector screenpos;
		VectorTransform( relativePosition, m_RenderToScreen, screenpos );
		renderGeometry.m_Positions.AddToTail( Vector2D( screenpos.x, screenpos.y ) );;
		// TexCoord
		renderGeometry.m_TextureCoords.AddToTail( m_TextureCoords[i] );
		// Vertex Color
		renderGeometry.m_VertexColors.AddToTail( m_VertexColors[i] );
	}

	// Triangles
	nCount = m_Triangles.Count();
	for ( int i = 0; i < nCount; ++i )
	{
		renderGeometry.m_Triangles.AddToTail( m_Triangles[i] );	
	}

	// Anim Info														   
	renderGeometry.m_SheetSequenceNumber = m_SheetSequenceNumber;
	renderGeometry.m_AnimationRate = m_AnimationRate;
	renderGeometry.m_bAnimate = m_bAnimate;
	renderGeometry.m_AnimStartTime = m_AnimStartTime;
	renderGeometry.m_pImageAlias = NULL;

	CalculateExtents();
}


//-----------------------------------------------------------------------------
// Calculate the rectangular extents of this graphic.
//-----------------------------------------------------------------------------
void CGeometry::CalculateExtentsMatrix( const StageRenderInfo_t &stageRenderInfo, const CGraphicGroup *pGroup )
{
	Assert( pGroup );

	// Update positions relative to the center, texture coords, and vertex colors
	// If the group maintains aspect ratio it will already have handled this in its transform update.
	Vector2D center;
	bool bUseMaintainedMatrix = m_bMaintainAspectRatio && !pGroup->MaintainAspectRatio();
	if ( bUseMaintainedMatrix )
	{
		// If this is the case we transform the center to screen coords first.
		// Then take into account any size scaling in the scalemat
		matrix3x4_t screenScalemat;
		SetScaleMatrix( stageRenderInfo.parentScale.x, stageRenderInfo.parentScale.y, 1, screenScalemat );
		Vector centerVec( m_Center.x, m_Center.y, 0 );
		Vector centerInScreen;
		VectorTransform( centerVec, screenScalemat, centerInScreen );
		center.x = centerInScreen.x;
		center.y = centerInScreen.y;
	}
	else
	{
		center = m_Center;
	}

	matrix3x4_t transmat;
	Vector position( center.x, center.y, 0 );
	SetIdentityMatrix( transmat );
	PositionMatrix( position, transmat );

	// TODO: account for scaling anims?
	matrix3x4_t scalemat;
	SetScaleMatrix( m_Scale.x, m_Scale.y, 1, scalemat );

	// Rotation is ignored.
	matrix3x4_t rotmat;
	Vector axis( 0, 0, 1 );
	MatrixBuildRotationAboutAxis( axis, 0, rotmat );

	matrix3x4_t temp;
	MatrixMultiply( rotmat, scalemat, temp );
	matrix3x4_t rawToLocal;
	MatrixMultiply( transmat, temp, rawToLocal );

	matrix3x4_t groupToScreen;
	// Use the matrix that doesn't contain any scale changes if we should
	pGroup->GetRenderTransform( groupToScreen, bUseMaintainedMatrix );
	MatrixMultiply( groupToScreen, rawToLocal, m_ExtentsMatrix );	
}

//-----------------------------------------------------------------------------
// Calculate the rectangular extents of this graphic.
//-----------------------------------------------------------------------------
void CGeometry::CalculateExtents()
{
	if ( !m_bDirtyExtents )
		return;

	// Now transform our array of positions into local graphic coord system.
	int nCount = m_RelativePositions.Count();
	CUtlVector< Vector2D > screenPositions;
	for ( int i = 0; i < nCount; ++i )
	{
		// Position
		Vector relativePosition( m_RelativePositions[i].x, m_RelativePositions[i].y, 0 );
		Vector screenpos;
		VectorTransform( relativePosition, m_ExtentsMatrix, screenpos );
		screenPositions.AddToTail( Vector2D( screenpos.x, screenpos.y ) );;
	}


	// left most position is x.
	m_Extents.m_TopLeft.x = INT_MAX;
	for ( int i = 0; i < screenPositions.Count(); ++i )
	{
		if ( m_Extents.m_TopLeft.x > screenPositions[i].x )
			m_Extents.m_TopLeft.x = screenPositions[i].x;
	}

	// top most position is y.
	m_Extents.m_TopLeft.y = INT_MAX;
	for ( int i = 0; i < screenPositions.Count(); ++i )
	{
		if ( m_Extents.m_TopLeft.y > screenPositions[i].y )
			m_Extents.m_TopLeft.y = screenPositions[i].y;
	}


	// right most position is x
	m_Extents.m_BottomRight.x = INT_MIN;
	for ( int i = 0; i < screenPositions.Count(); ++i )
	{
		if ( m_Extents.m_BottomRight.x < screenPositions[i].x )
			m_Extents.m_BottomRight.x = screenPositions[i].x;
	}


	// bottom most position is y
	m_Extents.m_BottomRight.y = INT_MIN;
	for ( int i = 0; i < screenPositions.Count(); ++i )
	{
		if ( m_Extents.m_BottomRight.y < screenPositions[i].y )
			m_Extents.m_BottomRight.y = screenPositions[i].y;
	}

	m_bDirtyExtents = false;
}


//-----------------------------------------------------------------------------
// Return the rectangular bounds of this object
//-----------------------------------------------------------------------------
void CGeometry::GetBounds( Rect_t &bounds )
{
	bounds.x = m_Extents.m_TopLeft.x;
	bounds.y = m_Extents.m_TopLeft.x;
	bounds.width = m_Extents.m_BottomRight.x - m_Extents.m_TopLeft.x;
	bounds.height = m_Extents.m_BottomRight.y - m_Extents.m_TopLeft.y;
}



//-----------------------------------------------------------------------------
// Purpose: Set the vertex colors of the graphic using the base color and the gradient colors.
//-----------------------------------------------------------------------------
void CGeometry::SetResultantColor( color32 parentColor )
{
	SetResultantColor( true, parentColor );
	SetResultantColor( false, parentColor );
}

//-----------------------------------------------------------------------------
// Purpose: Set the vertex colors of the graphic using the base color and the gradient colors.
//-----------------------------------------------------------------------------
void CGeometry::SetResultantColor( bool bTop, color32 parentColor )
{
	if ( bTop )
	{
		color32 localColor;
		localColor.r = (int)( (float)m_TopColor.r * (float)(m_Color.r/255.0) );
		localColor.g = (int)( (float)m_TopColor.g * (float)(m_Color.g/255.0) );
		localColor.b = (int)( (float)m_TopColor.b * (float)(m_Color.b/255.0) );	
		localColor.a = (int)( (float)m_TopColor.a * (float)(m_Color.a/255.0) );

		color32 resultantColor;
		resultantColor.r = (int)( (float)localColor.r * (float)(parentColor.r/255.0) );
		resultantColor.g = (int)( (float)localColor.g * (float)(parentColor.g/255.0) );
		resultantColor.b = (int)( (float)localColor.b * (float)(parentColor.b/255.0) );	
		resultantColor.a = (int)( (float)localColor.a * (float)(parentColor.a/255.0) );

		SetTopVerticesColor( resultantColor );
	}
	else 
	{
		color32 localColor;
		localColor.r = (int)( (float)m_BottomColor.r * (float)(m_Color.r/255.0) );
		localColor.g = (int)( (float)m_BottomColor.g * (float)(m_Color.g/255.0) );
		localColor.b = (int)( (float)m_BottomColor.b * (float)(m_Color.b/255.0) );	
		localColor.a = (int)( (float)m_BottomColor.a * (float)(m_Color.a/255.0) );

		color32 resultantColor;
		resultantColor.r = (int)( (float)localColor.r * (float)(parentColor.r/255.0) );
		resultantColor.g = (int)( (float)localColor.g * (float)(parentColor.g/255.0) );
		resultantColor.b = (int)( (float)localColor.b * (float)(parentColor.b/255.0) );	
		resultantColor.a = (int)( (float)localColor.a * (float)(parentColor.a/255.0) );

		SetBottomVerticesColor( resultantColor );
	}
}

//-----------------------------------------------------------------------------
// Note corner colors will be stomped if the base graphic's color changes.
//-----------------------------------------------------------------------------
void CGeometry::SetTopVerticesColor( color32 c )
{
	if ( m_bHorizontalGradient )
	{
		for ( int i = 0; i < m_VertexColors.Count(); i += 4 )
		{
			m_VertexColors[i] = c;
			m_VertexColors[i+3] = c;	
		}
	}
	else
	{
		for ( int i = 0; i < m_VertexColors.Count(); i += 4 )
		{
			m_VertexColors[i] = c;
			m_VertexColors[i+1] = c;	
		}
	}	
}

//-----------------------------------------------------------------------------
// Note corner colors will be stomped if the base graphic's color changes.
//-----------------------------------------------------------------------------
void CGeometry::SetBottomVerticesColor( color32 c )
{
	if ( m_bHorizontalGradient )
	{
		for ( int i = 0; i < m_VertexColors.Count(); i += 4 )
		{
			m_VertexColors[i+1] = c;
			m_VertexColors[i+2] = c;	
		}
	}
	else
	{
		for ( int i = 0; i < m_VertexColors.Count(); i += 4 )
		{
			m_VertexColors[i + 2] = c;
			m_VertexColors[i + 3] = c;
		}
	}
}

//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
void CGeometry::DrawExtents( CUtlVector< RenderGeometryList_t > &renderGeometryLists,  int firstListIndex, color32 extentLineColor )
{
	if ( !m_bVisible )
		return;

	float lineWidth = 2.0;
	// Time to invent some render data to draw this thing.
	{
		int i = renderGeometryLists[firstListIndex].AddToTail();
		CRenderGeometry &renderGeometry = renderGeometryLists[firstListIndex][i];

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );


		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_TopLeft.y + lineWidth ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_TopLeft.y + lineWidth ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		// Triangles
		CTriangle tri;
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 1;
		tri.m_PointIndex[2] = 2;
		renderGeometry.m_Triangles.AddToTail( tri );
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 2;
		tri.m_PointIndex[2] = 3;
		renderGeometry.m_Triangles.AddToTail( tri );
		
		// Anim Info														   
		renderGeometry.m_SheetSequenceNumber = 0;
		renderGeometry.m_AnimationRate = m_AnimationRate;
		renderGeometry.m_bAnimate = false;
		renderGeometry.m_AnimStartTime = m_AnimStartTime;
		renderGeometry.m_pImageAlias = NULL;
	}

	
	{
		// Time to invent some render data to draw this thing.
		int i = renderGeometryLists[firstListIndex].AddToTail();
		CRenderGeometry &renderGeometry = renderGeometryLists[firstListIndex][i];

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x - lineWidth, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_BottomRight.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x - lineWidth, m_Extents.m_BottomRight.y  ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		// Triangles
		CTriangle tri;
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 1;
		tri.m_PointIndex[2] = 2;
		renderGeometry.m_Triangles.AddToTail( tri );
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 2;
		tri.m_PointIndex[2] = 3;
		renderGeometry.m_Triangles.AddToTail( tri );

		// Anim Info														   
		renderGeometry.m_SheetSequenceNumber = 0;
		renderGeometry.m_AnimationRate = m_AnimationRate;
		renderGeometry.m_bAnimate = false;
		renderGeometry.m_AnimStartTime = m_AnimStartTime;
		renderGeometry.m_pImageAlias = NULL;
	}

	{
		int i = renderGeometryLists[firstListIndex].AddToTail();
		CRenderGeometry &renderGeometry = renderGeometryLists[firstListIndex][i];

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_BottomRight.y - lineWidth  ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_BottomRight.y - lineWidth ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );


		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_BottomRight.x, m_Extents.m_BottomRight.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );


		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_BottomRight.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

	 
		// Triangles
		CTriangle tri;
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 1;
		tri.m_PointIndex[2] = 2;
		renderGeometry.m_Triangles.AddToTail( tri );
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 2;
		tri.m_PointIndex[2] = 3;
		renderGeometry.m_Triangles.AddToTail( tri );

		// Anim Info														   
		renderGeometry.m_SheetSequenceNumber = 0;
		renderGeometry.m_AnimationRate = m_AnimationRate;
		renderGeometry.m_bAnimate = false;
		renderGeometry.m_AnimStartTime = m_AnimStartTime;
		renderGeometry.m_pImageAlias = NULL;
	}
	
	{
		// Time to invent some render data to draw this thing.
		int i = renderGeometryLists[firstListIndex].AddToTail();
		CRenderGeometry &renderGeometry = renderGeometryLists[firstListIndex][i];
	
		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x + lineWidth, m_Extents.m_TopLeft.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 0) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x + lineWidth, m_Extents.m_BottomRight.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 1 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );

		renderGeometry.m_Positions.AddToTail( Vector2D( m_Extents.m_TopLeft.x, m_Extents.m_BottomRight.y ) );
		renderGeometry.m_TextureCoords.AddToTail( Vector2D( 0 , 1) );
		renderGeometry.m_VertexColors.AddToTail( extentLineColor );


		// Triangles
		CTriangle tri;
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 1;
		tri.m_PointIndex[2] = 2;
		renderGeometry.m_Triangles.AddToTail( tri );
		tri.m_PointIndex[0] = 0;
		tri.m_PointIndex[1] = 2;
		tri.m_PointIndex[2] = 3;
		renderGeometry.m_Triangles.AddToTail( tri );

		// Anim Info														   
		renderGeometry.m_SheetSequenceNumber = 0;
		renderGeometry.m_AnimationRate = m_AnimationRate;
		renderGeometry.m_bAnimate = false;
		renderGeometry.m_AnimStartTime = m_AnimStartTime;
		renderGeometry.m_pImageAlias = NULL;
	}
	
}












//-----------------------------------------------------------------------------
// 
//-----------------------------------------------------------------------------
int CRenderGeometry::GetTriangleCount()
{
	return m_Triangles.Count();
}

int CRenderGeometry::GetVertexCount()
{
	return m_Positions.Count();
}


DmeTime_t CRenderGeometry::GetAnimStartTime()
{
	return m_AnimStartTime;
}



//-----------------------------------------------------------------------------
// Return true if the point x, y lies inside the triangle.
// Triangle points should be supplied in clockwise dir.
//-----------------------------------------------------------------------------
bool PointTriangleHitTest( Vector2D tringleVert0, Vector2D tringleVert1, Vector2D tringleVert2, Vector2D point )
{
	// Compute vectors 
	Vector2D v0 = tringleVert2 - tringleVert0;
	Vector2D v1 = tringleVert1 - tringleVert0;
	Vector2D v2 = point - tringleVert0;

	// Compute dot products
	float dot00 = v0.Dot( v0 );
	float dot01 = v0.Dot( v1 );
	float dot02 = v0.Dot( v2 );
	float dot11 = v1.Dot( v1 );
	float dot12 = v1.Dot( v2 );

	// Compute barycentric coordinates
	float invDenom = 1 / (dot00 * dot11 - dot01 * dot01);
	float u = (dot11 * dot02 - dot01 * dot12) * invDenom;
	float v = (dot00 * dot12 - dot01 * dot02) * invDenom;

	// Check if point is in triangle
	return ( u > 0 ) && ( v > 0 ) && ( u + v < 1 );
}