#include "ivmanualmeshloader.h"
#include "ivreader.h"

IVManualMeshLoader::IVManualMeshLoader()
{
	data = NULL;
}


IVManualMeshLoader::IVManualMeshLoader(IVMeshData *mData)
{
	data = mData;
/*	data = new IVMeshData();
	if ((mData->indices != NULL) && (mData->icnt > 0))
	{
		data->icnt = mData->icnt;
		data->indices = new Ogre::Real[mData->icnt];
		memcpy(data->indices, mData->indices, mData->icnt*sizeof(Ogre::Real));
	}
	if ((mData->vertices != NULL) && (mData->vcnt > 0))
	{
		data->vcnt = mData->vcnt;
		data->vertices = new Ogre::Real[mData->vcnt];
		memcpy(data->vertices, mData->vertices, mData->vcnt*sizeof(Ogre::Real));
	}
	if ((mData->normals != NULL) && (mData->vcnt > 0))
	{
		data->ncnt = mData->ncnt;
		data->normals = new Ogre::Real[mData->ncnt];
		memcpy(data->normals, mData->normals, mData->ncnt*sizeof(Ogre::Real));
	}
	if ((mData->texCoords != NULL) && (mData->tcnt > 0))
	{
		data->tcnt = mData->tcnt;
		data->texCoords = new Ogre::Real[mData->tcnt];
		memcpy(data->texCoords, mData->texCoords, mData->tcnt*sizeof(Ogre::Real));
	}
	*/
}

IVManualMeshLoader::~IVManualMeshLoader()
{
/*	if (data != NULL)
	{
		if (data->vertices != NULL)		delete [] data->vertices;
		if (data->normals != NULL)		delete [] data->normals;
		if (data->texCoords != NULL)	delete [] data->texCoords;
		if (data->indices != NULL)		delete [] data->indices;
		delete data;
	}
	*/
	if (data != NULL)
	{
		data->collapse();
		delete data;
	}
}


Ogre::AxisAlignedBox *IVManualMeshLoader::getBoundingBox()
{
	return data->boundingBox;
}


void IVManualMeshLoader::loadResource(Ogre::Resource *resource)
{
	using namespace Ogre;
	Mesh *pMesh = (Mesh *) resource;


	Vector3 translation = data->boundingBox->getCenter();

	bool nOk = ((data->normals != NULL) && (data->ncnt > 0));
	bool tOk = ((data->texCoords != NULL) && (data->tcnt > 0));
	
	pMesh->sharedVertexData = new VertexData(); 

	VertexDeclaration* vertexDecl = pMesh->sharedVertexData->vertexDeclaration; 

	size_t currOffset = 0; 
	vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_POSITION); 
	currOffset += VertexElement::getTypeSize(VET_FLOAT3); 
	if (nOk)
	{
		vertexDecl->addElement(0, currOffset, VET_FLOAT3, VES_NORMAL); 
		currOffset += VertexElement::getTypeSize(VET_FLOAT3); 
	}
    if (tOk)
	{
		vertexDecl->addElement(0, currOffset, VET_FLOAT2, VES_TEXTURE_COORDINATES); 
		currOffset += VertexElement::getTypeSize(VET_FLOAT2); 
	}

	pMesh->sharedVertexData->vertexCount = data->vcnt/3; 
	HardwareVertexBufferSharedPtr vbuf = 
		HardwareBufferManager::getSingleton(). 
		createVertexBuffer(vertexDecl->getVertexSize(0), pMesh->sharedVertexData->vertexCount, 
			HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); 

	VertexBufferBinding* binding = pMesh->sharedVertexData->vertexBufferBinding; 
	binding->setBinding(0, vbuf); 

	Real* pVertices = static_cast<Real*>(vbuf->lock(HardwareBuffer::HBL_DISCARD)); 

	int offset = 0, size = 3;
	if (nOk) size += 3;
	if (tOk) size += 2;
	for (int i=0; i<data->vcnt/3; i++) 
	{
		pVertices[i*size]   = data->vertices[i*3]   - translation.x;
		pVertices[i*size+1] = data->vertices[i*3+1] - translation.y;
		pVertices[i*size+2] = data->vertices[i*3+2] - translation.z;

		offset = 3;
		if (nOk)
		{
			pVertices[i*size+offset] = data->normals[i*3];	 offset++;
			pVertices[i*size+offset] = data->normals[i*3+1]; offset++;
			pVertices[i*size+offset] = data->normals[i*3+2]; offset++;
		}
		if (tOk)
		{
			pVertices[i*size+offset] = data->texCoords[i*2];   offset++;
			pVertices[i*size+offset] = -data->texCoords[i*2+1]; offset++;
		}
	}

	vbuf->unlock(); 


	SubMesh *pSub = pMesh->createSubMesh(); 
	pSub->operationType = RenderOperation::OT_TRIANGLE_LIST; //;data->roType;
	pSub->useSharedVertices = true; 

	pSub->indexData->indexCount = data->icnt; 
	pSub->indexData->indexBuffer = HardwareBufferManager::getSingleton(). 
		createIndexBuffer(HardwareIndexBuffer::IT_16BIT, 
			pSub->indexData->indexCount, HardwareBuffer::HBU_STATIC_WRITE_ONLY, false); 

	HardwareIndexBufferSharedPtr ibuf = pSub->indexData->indexBuffer; 
	unsigned short* pIndices = static_cast<unsigned short*>(ibuf->lock(HardwareBuffer::HBL_DISCARD)); 

	for (i = 0; i < data->icnt; i++) pIndices[i] = data->indices[i];
	
	ibuf->unlock(); 
		
	AxisAlignedBox bb(data->boundingBox->getMinimum() - translation, data->boundingBox->getMaximum() - translation);
	//AxisAlignedBox bb(data->boundingBox->getMinimum(), data->boundingBox->getMaximum());
	pMesh->_setBounds(bb); 
	Real radius = data->boundingBox->getMinimum().length();
	if (data->boundingBox->getMaximum().length() > radius) radius = data->boundingBox->getMaximum().length();
	pMesh->_setBoundingSphereRadius(radius); 

}