#include "vertexbuffer.h"

using namespace std;

VertexBuffer::~VertexBuffer()
{
	if (indices) delete[] indices;
	if (verts) delete[] verts;
	if (norms) delete[] norms;
	if (colors) delete[] colors;
	if (texcoordsarr)
	{
		for (register unsigned int i=0; i<numtextures; i++) delete[] texcoordsarr[i];
		delete[] texcoordsarr;
	}
}

void VertexBuffer::NumIndices(unsigned int num)
{
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES)
	{
		if (indices) delete[] indices;
		indices=new unsigned int[num];
		numindices=num;
	}
}

unsigned int VertexBuffer::NumIndices()
{
	return numindices;
}

void VertexBuffer::NumVerts(unsigned int num)
{
	if (verts) delete[] verts;
	if (norms) delete[] norms;
	if (colors) delete[] colors;
	
	interleavedvertsize=0;
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES)
	{
		interleavedvertsize+=sizeof(Vector3);
		verts=new Vector3[num];
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)
	{
		interleavedvertsize+=sizeof(Vector3);
		norms=new Vector3[num];
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		interleavedvertsize+=sizeof(Vector4);
		colors=new Vector4[num];
	}

	numverts=num;

	if (texcoordsarr&&(vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS))
	{
		interleavedvertsize+=sizeof(Vector2)*numtextures;
		for (register unsigned int i=0; i<numtextures; i++)
		{
			delete[] texcoordsarr[i];
			texcoordsarr[i]=new Vector2[numverts];
		}
	}
}

unsigned int VertexBuffer::NumVerts()
{
	return numverts;
}

void VertexBuffer::NumTextures(unsigned int num)
{
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		if (texcoordsarr)
		{
			for (register unsigned int i=0; i<numtextures; i++) delete[] texcoordsarr[i];
			delete[] texcoordsarr;
		}

		numtextures=num;

		texcoordsarr=new Vector2 *[numtextures];
		for (register unsigned int i=0; i<numtextures; i++) texcoordsarr[i]=new Vector2[numverts];
	}
}

unsigned int VertexBuffer::NumTextures()
{
	return numtextures;
}

void VertexBuffer::SetInterleaved(void *data)
{
	char *bytes=(char *)data;
	register unsigned int i;
	register unsigned int subptr=0;
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES)
	{
		for (i=0; i<numverts; i++)
			memcpy(verts+i,bytes+interleavedvertsize*i,sizeof(Vector3));
		subptr+=sizeof(Vector3);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)
	{
		for (i=0; i<numverts; i++)
			memcpy(norms+i,bytes+interleavedvertsize*i+subptr,sizeof(Vector3));
		subptr+=sizeof(Vector3);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		for (i=0; i<numverts; i++)
			memcpy(colors+i,bytes+interleavedvertsize*i+subptr,sizeof(Vector4));
		subptr+=sizeof(Vector4);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		for (i=0; i<numtextures; i++)
		{
			register unsigned int texptr=sizeof(Vector2)*i;
			Vector2 *texcoords=texcoordsarr[i];
			for (register unsigned int j=0; j<numverts; j++)
				memcpy(texcoords+j,bytes+(interleavedvertsize*j+subptr+texptr),sizeof(Vector2));
		}
	}
}

void VertexBuffer::Set(int type,int idx,void *data)
{
	switch (type)
	{
	case RAVEN_GEOMETRY_FLAG_INDICES:
		memcpy(indices,data,sizeof(unsigned int)*numindices);
		break;
	case RAVEN_GEOMETRY_FLAG_VERTICES:
		memcpy(verts,data,sizeof(Vector3)*numverts);
		break;
	case RAVEN_GEOMETRY_FLAG_NORMALS:
		memcpy(norms,data,sizeof(Vector3)*numverts);
		break;
	case RAVEN_GEOMETRY_FLAG_COLORS:
		memcpy(colors,data,sizeof(Vector4)*numverts);
		break;
	case RAVEN_GEOMETRY_FLAG_TEXCOORDS:
		memcpy(texcoordsarr[idx],data,sizeof(Vector2)*numverts);
		break;
	};
}

unsigned int VertexBuffer::Size(int type)
{
	switch (type)
	{
	case RAVEN_GEOMETRY_FLAG_INDICES:
		return sizeof(unsigned int)*numindices;
	case RAVEN_GEOMETRY_FLAG_VERTICES:
		return sizeof(Vector3)*numverts;
	case RAVEN_GEOMETRY_FLAG_NORMALS:
		return sizeof(Vector3)*numverts;
	case RAVEN_GEOMETRY_FLAG_COLORS:
		return sizeof(Vector4)*numverts;
	case RAVEN_GEOMETRY_FLAG_TEXCOORDS:
		return sizeof(Vector2)*numverts;
	default:
		return 0;
	};
}

void VertexBuffer::Get(int type,int idx,void **data)
{
	switch (type)
	{
	case RAVEN_GEOMETRY_FLAG_INDICES:
		*data=indices;
		break;
	case RAVEN_GEOMETRY_FLAG_VERTICES:
		*data=verts;
		break;
	case RAVEN_GEOMETRY_FLAG_NORMALS:
		*data=norms;
		break;
	case RAVEN_GEOMETRY_FLAG_COLORS:
		*data=colors;
		break;
	case RAVEN_GEOMETRY_FLAG_TEXCOORDS:
		*data=texcoordsarr[idx];
		break;
	default:
		break;
	};
}

int VertexBuffer::GetBufAttribs()
{
	return vbufattribs;
}

bool VertexBuffer::IsSoftBuffer() {return true;}
bool VertexBuffer::Render(GeometryType geomtype) {return false;}