//+-----------------------------------------------------------------------------
//| Included files
//+-----------------------------------------------------------------------------
#include "ModelGeoset.h"


//+-----------------------------------------------------------------------------
//| Constructor
//+-----------------------------------------------------------------------------
MODEL_GEOSET::MODEL_GEOSET()
{
	MeshBuildt = TRUE;

	GeosetAlpha = 1.0f;
	GeosetColor = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

	MaterialNode.SetData(this);
	BoneNodes.SetData(this);
	GeosetAnimationNodes.SetData(this);
}


//+-----------------------------------------------------------------------------
//| Destructor
//+-----------------------------------------------------------------------------
MODEL_GEOSET::~MODEL_GEOSET()
{
	Clear();
}


//+-----------------------------------------------------------------------------
//| Clears the geoset
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::Clear()
{
	INT i;

	for(i = 0; i < GeosetData.GroupContainer.GetTotalSize(); i++)
	{
		if(GeosetData.GroupContainer.ValidIndex(i))
		{
			GeosetData.GroupContainer[i]->Clear();
		}
	}

	SAFE_CLEAR(GeosetData.VertexContainer);
	SAFE_CLEAR(GeosetData.FaceContainer);
	SAFE_CLEAR(GeosetData.GroupContainer);
	SAFE_CLEAR(GeosetData.ExtentContainer);

	MeshBuildt = TRUE;

	GeosetAlpha = 1.0f;
	GeosetColor = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);

	GeosetData = MODEL_GEOSET_DATA();
}


//+-----------------------------------------------------------------------------
//| Returns the mdx size of the geoset
//+-----------------------------------------------------------------------------
INT MODEL_GEOSET::GetSize()
{
	INT i;
	INT Size = 136;

	Size += (GeosetData.VertexContainer.GetSize() * 33);
	Size += (GeosetData.FaceContainer.GetSize() * 6);
	Size += (GeosetData.GroupContainer.GetSize() * 4);
	Size += (GeosetData.ExtentContainer.GetSize() * 28);

	for(i = 0; i < GeosetData.GroupContainer.GetTotalSize(); i++)
	{
		if(GeosetData.GroupContainer.ValidIndex(i))
		{
			Size += (GeosetData.GroupContainer[i]->MatrixListSize * 4);
		}
	}

	return Size;
}


//+-----------------------------------------------------------------------------
//| Returns a reference to the data
//+-----------------------------------------------------------------------------
MODEL_GEOSET_DATA& MODEL_GEOSET::Data()
{
	return GeosetData;
}


//+-----------------------------------------------------------------------------
//| Returns the render order
//+-----------------------------------------------------------------------------
INT MODEL_GEOSET::GetRenderOrder()
{
	if(!MaterialNode.IsAttached()) return 0;

	return MaterialNode.GetObjectData()->GetRenderOrder();
}


//+-----------------------------------------------------------------------------
//| Returns a reference to the alpha
//+-----------------------------------------------------------------------------
FLOAT& MODEL_GEOSET::Alpha()
{
	return GeosetAlpha;
}


//+-----------------------------------------------------------------------------
//| Returns a reference to the color
//+-----------------------------------------------------------------------------
D3DXCOLOR& MODEL_GEOSET::Color()
{
	return GeosetColor;
}


//+-----------------------------------------------------------------------------
//| Rebuilds the geoset the next time it's rendered
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::Rebuild()
{
	MeshBuildt = FALSE;
}


//+-----------------------------------------------------------------------------
//| Renders the geoset
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::Render(CONST SEQUENCE_TIME& Time, BOOL Animated)
{
	INT i;
	D3DXMATRIX Matrix;
	MESH* CurrentMesh;
	MODEL_MATERIAL* Material;
	MODEL_MATERIAL_LAYER* Layer;
	MODEL_TEXTURE_ANIMATION* TextureAnimation;

	D3DXMatrixIdentity(&Matrix);
	Graphics.SetWorldMatrix(Matrix);

	if(FlashingGeoset.IsFlashing()) MeshBuildt = FALSE;

	BuildMesh();

	if(Animated)
	{
		BuildAnimatedMesh(Time);
		CurrentMesh = &AnimatedMesh;

		if(GeosetAlpha <= 0.01f) return;
	}
	else
	{
		CurrentMesh = &Mesh;
	}

	if(!MaterialNode.IsAttached()) return;
	Material = MaterialNode.GetObjectData();

	for(i = 0; i < Material->Data().LayerContainer.GetTotalSize(); i++)
	{
		if(!Material->Data().LayerContainer.ValidIndex(i)) continue;
		Layer = Material->Data().LayerContainer[i];

		TextureAnimation = Layer->TextureAnimationNode.IsAttached() ? Layer->TextureAnimationNode.GetObjectData() : NULL;

		BuildAnimatedTexture(Time, TextureAnimation, Layer->Data().Alpha.GetScalar(Time));
		Layer->UseMaterial(Time);
		CurrentMesh->Render();
	}
}


//+-----------------------------------------------------------------------------
//| Renders the geoset in a view
//+-----------------------------------------------------------------------------
VOID MODEL_GEOSET::RenderInView()
{
	Mesh.Render();
}


//+-----------------------------------------------------------------------------
//| Builds a mesh from the vertex and face information
//+-----------------------------------------------------------------------------
BOOL MODEL_GEOSET::BuildMesh()
{
	INT i;
	INT NrOfVertices;
	INT NrOfFaces;
	VERTEX* VertexPointer;
	VERTEX* AnimatedVertexPointer;
	WORD* IndexPointer;
	WORD* AnimatedIndexPointer;
	D3DCOLOR Color;

	if(MeshBuildt) return TRUE;

	NrOfVertices = GeosetData.VertexContainer.GetSize();
	if(NrOfVertices <= 0) return FALSE;

	NrOfFaces = GeosetData.FaceContainer.GetSize();
	if(NrOfFaces <= 0) return FALSE;

	if(!Mesh.Create(NrOfVertices, NrOfFaces)) return FALSE;
	if(!AnimatedMesh.Create(NrOfVertices, NrOfFaces)) return FALSE;

	if(!Mesh.LockVertexBuffer(&VertexPointer)) return FALSE;
	if(!AnimatedMesh.LockVertexBuffer(&AnimatedVertexPointer))
	{
		Mesh.UnlockVertexBuffer();
		return FALSE;
	}

	if(FlashingGeoset.GetGeoset() == this)
	{
		D3DXCOLOR TempColor;

		TempColor = FlashingGeoset.GetColor();
		Color = D3DCOLOR_COLORVALUE(TempColor.r, TempColor.g, TempColor.b, TempColor.a);
	}
	else
	{
		Color = 0xFFFFFFFF;
	}

	for(i = 0; i < GeosetData.VertexContainer.GetTotalSize(); i++)
	{
		if(GeosetData.VertexContainer.ValidIndex(i))
		{
			VertexPointer->Position = GeosetData.VertexContainer[i]->Position;
			VertexPointer->Normal = GeosetData.VertexContainer[i]->Normal;
			VertexPointer->Color = Color;
			VertexPointer->TexturePosition = GeosetData.VertexContainer[i]->TexturePosition;

			AnimatedVertexPointer->Position = VertexPointer->Position;
			AnimatedVertexPointer->Normal = VertexPointer->Normal;
			AnimatedVertexPointer->Color = VertexPointer->Color;
			AnimatedVertexPointer->TexturePosition = VertexPointer->TexturePosition;

			VertexPointer++;
			AnimatedVertexPointer++;
		}
	}

	AnimatedMesh.UnlockVertexBuffer();
	Mesh.UnlockVertexBuffer();

	if(!Mesh.LockIndexBuffer(&IndexPointer)) return FALSE;
	if(!AnimatedMesh.LockIndexBuffer(&AnimatedIndexPointer))
	{
		Mesh.UnlockIndexBuffer();
		return FALSE;
	}

	for(i = 0; i < GeosetData.FaceContainer.GetTotalSize(); i++)
	{
		if(GeosetData.FaceContainer.ValidIndex(i))
		{
			(*IndexPointer) = GeosetData.FaceContainer[i]->Index1;
			(*AnimatedIndexPointer) = (*IndexPointer);
			IndexPointer++;
			AnimatedIndexPointer++;

			(*IndexPointer) = GeosetData.FaceContainer[i]->Index2;
			(*AnimatedIndexPointer) = (*IndexPointer);
			IndexPointer++;
			AnimatedIndexPointer++;

			(*IndexPointer) = GeosetData.FaceContainer[i]->Index3;
			(*AnimatedIndexPointer) = (*IndexPointer);
			IndexPointer++;
			AnimatedIndexPointer++;
		}
	}

	AnimatedMesh.UnlockIndexBuffer();
	Mesh.UnlockIndexBuffer();

	MeshBuildt = TRUE;

	return TRUE;
}


//+-----------------------------------------------------------------------------
//| Builds an animated mesh from the mesh and group information
//+-----------------------------------------------------------------------------
BOOL MODEL_GEOSET::BuildAnimatedMesh(CONST SEQUENCE_TIME& Time)
{
	INT i;
	INT j;
	INT GroupIndex;
	FLOAT TempAlpha;
	D3DXVECTOR3 TempColor;
	VERTEX* VertexPointer;
	VERTEX* AnimatedVertexPointer;
	MODEL_BASE* Node;
	MODEL_GEOSET_GROUP* GeosetGroup;
	MODEL_GEOSET_GROUP_NODE* GeosetGroupNode;
	REFERENCE<MODEL_GEOSET_ANIMATION*, MODEL_GEOSET*>* CurrentReference;

	if(FlashingGeoset.GetGeoset() == this)
	{
		GeosetAlpha = 1.0f;
		GeosetColor = FlashingGeoset.GetColor();
	}
	else
	{
		GeosetAlpha = 1.0f;
		GeosetColor = D3DXCOLOR(1.0f, 1.0f, 1.0f, 1.0f);
	}

	CurrentReference = GeosetAnimationNodes.GetFirstReference();
	while(CurrentReference != NULL)
	{
		TempAlpha = CurrentReference->GetData()->Data().Alpha.GetScalar(Time);
		GeosetAlpha *= TempAlpha;

		if(CurrentReference->GetData()->Data().UseColor)
		{
			TempColor = CurrentReference->GetData()->Data().Color.GetVector3(Time);
			GeosetColor.r *= TempColor.z;
			GeosetColor.g *= TempColor.y;
			GeosetColor.b *= TempColor.x;
			GeosetColor.a *= TempAlpha;
		}

		CurrentReference = GeosetAnimationNodes.GetNextReference(CurrentReference);