PhatAC/Polygon.cpp

#include "StdAfx.h"
#include "Vertex.h"
#include "Polygon.h"

CVertexArray *CPolygon::pack_verts;

CPolygon::CPolygon()
{
	m_pVertexObjects = NULL;
	m_pVertexIndices = NULL;

	m_iPolyIndex = -1;

	m_iVertexCount = 0;
	m_iPolyType = 0;

	m_iCullType = 0;
	m_Face1_UVIndices = NULL;
	m_Face2_UVIndices = NULL;
	m_Face1_TexIndex = -1;
	m_Face2_TexIndex = -1;

	m_pVertexUnks = NULL;
}

CPolygon::~CPolygon()
{
	Destroy();
}

void CPolygon::Destroy()
{
	if (m_Face1_UVIndices)
	{
		delete[] m_Face1_UVIndices;
		m_Face1_UVIndices = NULL;
	}

	if (m_iCullType == 2)
	{
		if (m_Face2_UVIndices)
		{
			delete[] m_Face2_UVIndices;
			m_Face2_UVIndices = NULL;
		}
	}

	if (m_pVertexObjects)
	{
		delete[] m_pVertexObjects;
		m_pVertexObjects = NULL;
	}

	if (m_pVertexIndices)
	{
		delete[] m_pVertexIndices;
		m_pVertexIndices = NULL;
	}

	if (m_pVertexUnks)
	{
		delete[] m_pVertexUnks;
		m_pVertexUnks = NULL;
	}

	m_iVertexCount = 0;
	m_iPolyType = 0;
	m_Face1_TexIndex = -1;
	m_Face2_TexIndex = -1;
	m_iPolyIndex = -1;

}

void CPolygon::SetPackVerts(CVertexArray *Verts)
{
	pack_verts = Verts;
}

BOOL CPolygon::UnPack(BYTE** ppData, ULONG iSize)
{
	UNPACK(short, m_iPolyIndex);

	UNPACK(BYTE, m_iVertexCount);
	UNPACK(BYTE, m_iPolyType);

	UNPACK(DWORD, m_iCullType);
	UNPACK(short, m_Face1_TexIndex);
	UNPACK(short, m_Face2_TexIndex);

	m_pVertexObjects = new CSWVertex*[m_iVertexCount];
	m_pVertexIndices = new WORD[m_iVertexCount];
	m_pVertexUnks = new CSWVertex*[m_iVertexCount];

	for (DWORD i = 0; i < m_iVertexCount; i++)
	{
		WORD Index;
		UNPACK(WORD, Index);

		m_pVertexIndices[i] = Index;
		m_pVertexObjects[i] = (CSWVertex *)((BYTE *)pack_verts->m_pVertexBuffer + Index * CVertexArray::vertex_size);
	}

	if (!(m_iPolyType & 4))
	{
		m_Face1_UVIndices = new BYTE[m_iVertexCount];

		for (DWORD i = 0; i < m_iVertexCount; i++)
			UNPACK(BYTE, m_Face1_UVIndices[i]);
	}

	if ((m_iCullType == 2) && !(m_iPolyType & 8))
	{
		m_Face2_UVIndices = new BYTE[m_iVertexCount];

		for (DWORD i = 0; i < m_iVertexCount; i++)
			UNPACK(BYTE, m_Face2_UVIndices[i]);
	}

	if (m_iCullType == CullNone)
	{
		m_Face2_TexIndex = m_Face1_TexIndex;
		m_Face2_UVIndices = m_Face1_UVIndices;
	}

#ifdef PRE_TOD
	PACK_ALIGN();
#endif

	make_plane();

	return TRUE;
}

void CPolygon::make_plane()
{
	// Not meant for human eyes.
	int i;
	CSWVertex *pPin;
	CSWVertex **ppSpread;

	Vector Norm(0, 0, 0);

	for (i = m_iVertexCount - 2, pPin = m_pVertexObjects[0], ppSpread = &m_pVertexObjects[1]; i > 0; i--, ppSpread++)
	{
		Vector V1 = ppSpread[0]->origin - pPin->origin;
		Vector V2 = ppSpread[1]->origin - pPin->origin;

		Norm = Norm + cross_product(V1, V2);
	}

	Norm.normalize();

	float distsum = 0;

	for (i = m_iVertexCount, ppSpread = m_pVertexObjects; i > 0; i--, ppSpread++)
		distsum += Norm.dot_product(ppSpread[0]->origin);

	m_plane.m_dist = -(distsum / m_iVertexCount);
	m_plane.m_normal = Norm;
}

BOOL CPolygon::polygon_hits_ray(const Ray& ray, float *time)
{
	// return peafixed_polygon_hits_ray(ray, time);

	if (!m_iCullType && (m_plane.m_normal.dot_product(ray.m_direction) > 0))
		return FALSE;

	if (!m_plane.compute_time_of_intersection(ray, time))
		return FALSE;

	return point_in_polygon(ray.m_origin + (ray.m_direction * (*time)));
}

BOOL CPolygon::peafixed_polygon_hits_ray(const Ray& ray, float *depth)
{
	if (!m_iCullType && (m_plane.m_normal.dot_product(ray.m_direction) > 0))
		return FALSE;

	float u, v;

	for (int i = 1; i < m_iVertexCount - 1;)
	{
		CSWVertex* CurrVertex1 = m_pVertexObjects[0];
		CSWVertex* CurrVertex2 = m_pVertexObjects[i];
		CSWVertex* CurrVertex3 = m_pVertexObjects[++i];

		if (D3DXIntersectTri(
			(D3DXVECTOR3 *)&CurrVertex1->origin,
			(D3DXVECTOR3 *)&CurrVertex2->origin,
			(D3DXVECTOR3 *)&CurrVertex3->origin,
			(D3DXVECTOR3 *)&ray.m_origin,
			(D3DXVECTOR3 *)&ray.m_direction,
			&u, &v, depth))
			return TRUE;
	}

	return FALSE;
}

BOOL CPolygon::point_in_polygon(const Vector& point)
{
	CSWVertex* LastVertex = m_pVertexObjects[m_iVertexCount - 1];

	for (int i = 0; i < m_iVertexCount; i++)
	{
		CSWVertex* CurrVertex = m_pVertexObjects[i];

		Vector crossp =
			cross_product(m_plane.m_normal, CurrVertex->origin - LastVertex->origin);

		float dotp = crossp.dot_product(point - LastVertex->origin);

		if (dotp < 0.0)
			return FALSE;

		LastVertex = CurrVertex;
	}

	return TRUE;
}

//
// For ray-tracing vertices -- something not in the client.
//

CSWVertex *PickVertexFromPolygon(CPolygon *pPoly, const Ray& ray)
{
	if (!pPoly->m_iCullType && (pPoly->m_plane.m_normal.dot_product(ray.m_direction) > 0))
		return FALSE;

	float curr_depth = FLT_MAX;

	CSWVertex*
		result = NULL;

	for (int i = 1; i < pPoly->m_iVertexCount - 1;)
	{
		CSWVertex* CurrVertex1 = pPoly->m_pVertexObjects[0];
		CSWVertex* CurrVertex2 = pPoly->m_pVertexObjects[i];
		CSWVertex* CurrVertex3 = pPoly->m_pVertexObjects[++i];

		float u, v, depth;
		if (D3DXIntersectTri(
			(D3DXVECTOR3 *)&CurrVertex1->origin,
			(D3DXVECTOR3 *)&CurrVertex2->origin,
			(D3DXVECTOR3 *)&CurrVertex3->origin,
			(D3DXVECTOR3 *)&ray.m_origin,
			(D3DXVECTOR3 *)&ray.m_direction,
			&u, &v, &depth) && (depth < curr_depth))
		{
			Vector u_scalar = (CurrVertex2->origin - CurrVertex1->origin);
			Vector v_scalar = (CurrVertex3->origin - CurrVertex1->origin);
			Vector face_point = CurrVertex1->origin + (u_scalar * u) + (v_scalar * v);

			float vdist1 = (face_point - CurrVertex1->origin).magnitude();
			float vdist2 = (face_point - CurrVertex2->origin).magnitude();
			float vdist3 = (face_point - CurrVertex3->origin).magnitude();

			if (vdist1 <= vdist2)
				result = ((vdist1 <= vdist3) ? CurrVertex1 : CurrVertex3);
			else
				result = ((vdist2 <= vdist3) ? CurrVertex2 : CurrVertex3);
		}
	}

	return result;
}