#include "Model.h"

Model::Model()
{
}

Model::~Model()
{
}

const vector<Polygon3D>& Model::GetPolygons()
{
	return _polygons;
}

const vector<Vertex>& Model::GetVertices()
{
	return _vertices;
}

const vector<Matrix>& Model::GetPendingTransforms()
{
	return _pendingTransforms;
}

size_t Model::GetPolygonCount()
{
	return _polygons.size();
}

size_t Model::GetVerticesCount()
{
	return _vertices.size();
}

size_t Model::GetPendingTransformCount()
{
	return _pendingTransforms.size();
}

void Model::AddVertex(float x, float y, float z)
{
	_vertices.push_back(Vertex(x, y, z));
	_transformedVertices.push_back(Vertex(x, y, z));
}

void Model::AddPolygon(int index0, int index1, int index2)
{
	_polygons.push_back(Polygon3D(index0, index1, index2));
}

void Model::EnqueueTransform(Matrix transform)
{
	_pendingTransforms.push_back(transform);
}

void Model::ClearPendingTransforms()
{
	_pendingTransforms.clear();
}

const Polygon3D& Model::GetPolygon(int index)
{
	return _polygons[index];
}

const Vertex& Model::GetVertex(int polygonIndex, int vertexPolygonIndex)
{
	return GetVertex(GetPolygon(polygonIndex).GetIndex(vertexPolygonIndex));          
}

const Vertex& Model::GetVertex(int index)
{
	return _transformedVertices[index];
}

void Model::ApplyTransformToLocalVertices(const Matrix& transform)
{
	for (int i = 0; i < GetVerticesCount(); i++)
	{
		_transformedVertices[i] = transform * _vertices[i];
	}
}

void Model::ApplyTransformToTransformedVertices(const Matrix& transform)
{
	for (int i = 0; i < GetVerticesCount(); i++)
	{
		_transformedVertices[i] = transform * _transformedVertices[i];
	}
}

void Model::DehomogenizeAllVertices()
{
	for (Vertex &currentVertex : _transformedVertices)
	{
		currentVertex.Dehomogenize();
	}
}

void Model::CalculateBackfaces(Camera& currentCamera)
{
	for (Polygon3D &currentPolygon : _polygons)
	{
		Vector3D vectorA = _transformedVertices[currentPolygon.GetIndex(1)] - _transformedVertices[currentPolygon.GetIndex(0)];
		Vector3D vectorB = _transformedVertices[currentPolygon.GetIndex(2)] - _transformedVertices[currentPolygon.GetIndex(0)];
		currentPolygon.SetNormal(Vector3D::CrossProduct(vectorA, vectorB));
		Vector3D eyeVector = _transformedVertices[currentPolygon.GetIndex(0)] - currentCamera.GetCurrentPosition();

		float dotProduct = Vector3D::DotProduct(currentPolygon.GetNormal(), eyeVector);
		if (dotProduct < 0)
		{
			currentPolygon.SetCulled(true);
		}
		else
		{
			currentPolygon.SetCulled(false);
		}
	}
}

bool DepthCompare(Polygon3D& a, Polygon3D& b)
{
	return a.GetDepth() > b.GetDepth();
}

void Model::Sort()
{
	for (Polygon3D &currentPolygon : _polygons)
	{
		float zTotal = 0.0f;
		for (int i = 0; i < currentPolygon.GetPolygonVertexCount(); i++)
		{
			zTotal += _transformedVertices[currentPolygon.GetIndex(i)].GetZ();
		}
		currentPolygon.SetDepth(zTotal / currentPolygon.GetPolygonVertexCount());
	}

	sort(_polygons.begin(), _polygons.end(), DepthCompare);
}