//========= Copyright Valve Corporation, All rights reserved. ============//
//
// Purpose: 
//
// $NoKeywords: $
//=============================================================================//

#include "disp_vrad.h"
#include "utllinkedlist.h"
#include "utlvector.h"
#include "iscratchpad3d.h"
#include "scratchpadutils.h"


//#define USE_SCRATCHPAD
#if defined( USE_SCRATCHPAD )
static IScratchPad3D *g_pPad = 0;
#endif


int FindNeighborCornerVert(CCoreDispInfo *pDisp, const Vector &vTest)
{
	CDispUtilsHelper *pDispHelper = pDisp;

	int iClosest = 0;
	float flClosest = 1e24;
	for (int iCorner = 0; iCorner < 4; iCorner++)
	{
		// Has it been touched?
		CVertIndex cornerVert = pDispHelper->GetPowerInfo()->GetCornerPointIndex(iCorner);
		int iCornerVert = pDispHelper->VertIndexToInt(cornerVert);
		const Vector &vCornerVert = pDisp->GetVert(iCornerVert);

		float flDist = vCornerVert.DistTo(vTest);
		if (flDist < flClosest)
		{
			iClosest = iCorner;
			flClosest = flDist;
		}
	}

	if (flClosest <= 0.1f)
		return iClosest;
	else
		return -1;
}


int GetAllNeighbors(const CCoreDispInfo *pDisp, int(&iNeighbors)[512])
{
	int nNeighbors = 0;

	// Check corner neighbors.
	for (int iCorner = 0; iCorner < 4; iCorner++)
	{
		const CDispCornerNeighbors *pCorner = pDisp->GetCornerNeighbors(iCorner);

		for (int i = 0; i < pCorner->m_nNeighbors; i++)
		{
			if (nNeighbors < ARRAYSIZE(iNeighbors))
				iNeighbors[nNeighbors++] = pCorner->m_Neighbors[i];
		}
	}

	for (int iEdge = 0; iEdge < 4; iEdge++)
	{
		const CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor(iEdge);

		for (int i = 0; i < 2; i++)
		{
			if (pEdge->m_SubNeighbors[i].IsValid())
				if (nNeighbors < 512)
					iNeighbors[nNeighbors++] = pEdge->m_SubNeighbors[i].GetNeighborIndex();
		}
	}

	return nNeighbors;
}


void BlendCorners(CCoreDispInfo **ppListBase, int listSize)
{
	CUtlVector<int> nbCornerVerts;

	for (int iDisp = 0; iDisp < listSize; iDisp++)
	{
		CCoreDispInfo *pDisp = ppListBase[iDisp];

		int iNeighbors[512];
		int nNeighbors = GetAllNeighbors(pDisp, iNeighbors);

		// Make sure we have room for all the neighbors.
		nbCornerVerts.RemoveAll();
		nbCornerVerts.EnsureCapacity(nNeighbors);
		nbCornerVerts.AddMultipleToTail(nNeighbors);

		// For each corner.
		for (int iCorner = 0; iCorner < 4; iCorner++)
		{
			// Has it been touched?
			CVertIndex cornerVert = pDisp->GetCornerPointIndex(iCorner);
			int iCornerVert = pDisp->VertIndexToInt(cornerVert);
			const Vector &vCornerVert = pDisp->GetVert(iCornerVert);

			// For each displacement sharing this corner..
			Vector vAverage = pDisp->GetNormal(iCornerVert);

			for (int iNeighbor = 0; iNeighbor < nNeighbors; iNeighbor++)
			{
				int iNBListIndex = iNeighbors[iNeighbor];
				CCoreDispInfo *pNeighbor = ppListBase[iNBListIndex];

				// Find out which vert it is on the neighbor.
				int iNBCorner = FindNeighborCornerVert(pNeighbor, vCornerVert);
				if (iNBCorner == -1)
				{
					nbCornerVerts[iNeighbor] = -1; // remove this neighbor from the list.
				}
				else
				{
					CVertIndex viNBCornerVert = pNeighbor->GetCornerPointIndex(iNBCorner);
					int iNBVert = pNeighbor->VertIndexToInt(viNBCornerVert);
					nbCornerVerts[iNeighbor] = iNBVert;
					vAverage += pNeighbor->GetNormal(iNBVert);
				}
			}


			// Blend all the neighbor normals with this one.
			VectorNormalize(vAverage);
			pDisp->SetNormal(iCornerVert, vAverage);

#if defined( USE_SCRATCHPAD )
			ScratchPad_DrawArrowSimple(
				g_pPad,
				pDisp->GetVert(iCornerVert),
				pDisp->GetNormal(iCornerVert),
				Vector(0, 0, 1),
				25);
#endif

			for (int iNeighbor = 0; iNeighbor < nNeighbors; iNeighbor++)
			{
				int iNBListIndex = iNeighbors[iNeighbor];
				if (nbCornerVerts[iNeighbor] == -1)
					continue;

				CCoreDispInfo *pNeighbor = ppListBase[iNBListIndex];
				pNeighbor->SetNormal(nbCornerVerts[iNeighbor], vAverage);
			}
		}
	}
}


void BlendTJuncs(CCoreDispInfo **ppListBase, int listSize)
{
	for (int iDisp = 0; iDisp < listSize; iDisp++)
	{
		CCoreDispInfo *pDisp = ppListBase[iDisp];

		for (int iEdge = 0; iEdge < 4; iEdge++)
		{
			CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor(iEdge);

			CVertIndex viMidPoint = pDisp->GetEdgeMidPoint(iEdge);
			int iMidPoint = pDisp->VertIndexToInt(viMidPoint);

			if (pEdge->m_SubNeighbors[0].IsValid() && pEdge->m_SubNeighbors[1].IsValid())
			{
				const Vector &vMidPoint = pDisp->GetVert(iMidPoint);

				CCoreDispInfo *pNeighbor1 = ppListBase[pEdge->m_SubNeighbors[0].GetNeighborIndex()];
				CCoreDispInfo *pNeighbor2 = ppListBase[pEdge->m_SubNeighbors[1].GetNeighborIndex()];

				int iNBCorners[2];
				iNBCorners[0] = FindNeighborCornerVert(pNeighbor1, vMidPoint);
				iNBCorners[1] = FindNeighborCornerVert(pNeighbor2, vMidPoint);

				if (iNBCorners[0] != -1 && iNBCorners[1] != -1)
				{
					CVertIndex viNBCorners[2] =
					{
						pNeighbor1->GetCornerPointIndex(iNBCorners[0]),
						pNeighbor2->GetCornerPointIndex(iNBCorners[1])
					};

					Vector vAverage = pDisp->GetNormal(iMidPoint);
					vAverage += pNeighbor1->GetNormal(viNBCorners[0]);
					vAverage += pNeighbor2->GetNormal(viNBCorners[1]);

					VectorNormalize(vAverage);
					pDisp->SetNormal(iMidPoint, vAverage);
					pNeighbor1->SetNormal(viNBCorners[0], vAverage);
					pNeighbor2->SetNormal(viNBCorners[1], vAverage);

#if defined( USE_SCRATCHPAD )
					ScratchPad_DrawArrowSimple(g_pPad, pDisp->GetVert(iMidPoint), pDisp->GetNormal(iMidPoint), Vector(0, 1, 1), 25);
#endif
				}
			}
		}
	}
}


void BlendEdges(CCoreDispInfo **ppListBase, int listSize)
{
	for (int iDisp = 0; iDisp < listSize; iDisp++)
	{
		CCoreDispInfo *pDisp = ppListBase[iDisp];

		for (int iEdge = 0; iEdge < 4; iEdge++)
		{
			CDispNeighbor *pEdge = pDisp->GetEdgeNeighbor(iEdge);

			for (int iSub = 0; iSub < 2; iSub++)
			{
				CDispSubNeighbor *pSub = &pEdge->m_SubNeighbors[iSub];
				if (!pSub->IsValid())
					continue;

				CCoreDispInfo *pNeighbor = ppListBase[pSub->GetNeighborIndex()];

				int iEdgeDim = g_EdgeDims[iEdge];

				CDispSubEdgeIterator it;
				it.Start(pDisp, iEdge, iSub, true);

				// Get setup on the first corner vert.
				it.Next();
				CVertIndex viPrevPos = it.GetVertIndex();

				while (it.Next())
				{
					// Blend the two.
					if (!it.IsLastVert())
					{
						Vector vAverage = pDisp->GetNormal(it.GetVertIndex()) + pNeighbor->GetNormal(it.GetNBVertIndex());
						VectorNormalize(vAverage);

						pDisp->SetNormal(it.GetVertIndex(), vAverage);
						pNeighbor->SetNormal(it.GetNBVertIndex(), vAverage);

#if defined( USE_SCRATCHPAD )
						ScratchPad_DrawArrowSimple(g_pPad, pDisp->GetVert(it.GetVertIndex()), pDisp->GetNormal(it.GetVertIndex()), Vector(1, 0, 0), 25);
#endif
					}

					// Now blend the in-between verts (if this edge is high-res).
					int iPrevPos = viPrevPos[!iEdgeDim];
					int iCurPos = it.GetVertIndex()[!iEdgeDim];

					for (int iTween = iPrevPos + 1; iTween < iCurPos; iTween++)
					{
						float flPercent = RemapVal(iTween, iPrevPos, iCurPos, 0, 1);
						Vector vNormal;
						VectorLerp(pDisp->GetNormal(viPrevPos), pDisp->GetNormal(it.GetVertIndex()), flPercent, vNormal);
						VectorNormalize(vNormal);

						CVertIndex viTween;
						viTween[iEdgeDim] = it.GetVertIndex()[iEdgeDim];
						viTween[!iEdgeDim] = iTween;
						pDisp->SetNormal(viTween, vNormal);

#if defined( USE_SCRATCHPAD )
						ScratchPad_DrawArrowSimple(g_pPad, pDisp->GetVert(viTween), pDisp->GetNormal(viTween), Vector(1, 0.5, 0), 25);
#endif
					}

					viPrevPos = it.GetVertIndex();
				}
			}
		}
	}
}


#if defined( USE_SCRATCHPAD )
void ScratchPad_DrawOriginalNormals(const CCoreDispInfo *pListBase, int listSize)
{
	for (int i = 0; i < listSize; i++)
	{
		const CCoreDispInfo *pDisp = &pListBase[i];
		const CPowerInfo *pPowerInfo = pDisp->GetPowerInfo();

		// Draw the triangles.
		for (int iTri = 0; iTri < pPowerInfo->GetNumTriInfos(); iTri++)
		{
			const CTriInfo *pTriInfo = pPowerInfo->GetTriInfo(iTri);

			for (int iLine = 0; iLine < 3; iLine++)
			{
				const Vector &v1 = pDisp->GetVert(pTriInfo->m_Indices[iLine]);
				const Vector &v2 = pDisp->GetVert(pTriInfo->m_Indices[(iLine + 1) % 3]);

				g_pPad->DrawLine(CSPVert(v1), CSPVert(v2));
			}
		}

		// Draw the normals.
		CDispCircumferenceIterator it(pPowerInfo->GetSideLength());
		while (it.Next())
		{
			ScratchPad_DrawArrowSimple(
				g_pPad,
				pDisp->GetVert(it.GetVertIndex()),
				pDisp->GetNormal(it.GetVertIndex()),
				Vector(0, 1, 0),
				15);
		}
	}
}
#endif


void SmoothNeighboringDispSurfNormals(CCoreDispInfo **ppListBase, int listSize)
{
	//#if defined( USE_SCRATCHPAD )
	//	g_pPad = ScratchPad3D_Create();
	//	ScratchPad_DrawOriginalNormals( pListBase, listSize );
	//#endif

	BlendTJuncs(ppListBase, listSize);

	BlendCorners(ppListBase, listSize);

	BlendEdges(ppListBase, listSize);
}