#include "vertexbuffer_d3d9.h"

using namespace std;

void VertexBufferD3D9::CalculateSizeAndFVF()
{
	vertsize=sizeof(float)*3;
	fvf=D3DFVF_XYZ;

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)
	{
		norm_offset=vertsize;
		vertsize+=sizeof(float)*3;
		fvf|=D3DFVF_NORMAL;
	}

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		color_offset=vertsize;
		vertsize+=sizeof(DWORD);
		fvf|=D3DFVF_DIFFUSE;
	}

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		tex_offset=vertsize;
		vertsize+=sizeof(float)*2*numtextures;
		fvf|=numtextures<<D3DFVF_TEXCOUNT_SHIFT;
	}
}

VertexBufferD3D9::VertexBufferD3D9(LPDIRECT3DDEVICE9 dev,int attribs): dev(dev),
	VertexBuffer(attribs), numindices(0), numverts(0), numtextures(0), verts(NULL), indices(NULL)
{
	CalculateSizeAndFVF();
}

VertexBufferD3D9::~VertexBufferD3D9()
{
	if (indices) indices->Release();
	if (verts) verts->Release();
}

void VertexBufferD3D9::NumIndices(unsigned int num)
{
	numindices=num;

	if (indices) indices->Release();
	if (dev->CreateIndexBuffer(numindices*4/*4 bytes per index*/,D3DUSAGE_DONOTCLIP|D3DUSAGE_WRITEONLY,
		D3DFMT_INDEX32,D3DPOOL_MANAGED,&indices,NULL)!=D3D_OK)
	{
		numindices=0;	
		indices=NULL;
	}
}

void VertexBufferD3D9::NumVerts(unsigned int num)
{
	numverts=num;

	if (verts) verts->Release();
	if (dev->CreateVertexBuffer(numverts*vertsize,D3DUSAGE_DONOTCLIP|D3DUSAGE_WRITEONLY,
		fvf,D3DPOOL_MANAGED,&verts,NULL)!=D3D_OK)
	{
		numverts=0;
		verts=NULL;
	}
}

void VertexBufferD3D9::NumTextures(unsigned int num)
{
	numtextures=num;
	CalculateSizeAndFVF();

	if (verts) verts->Release();
	if (!numverts)
	{
		if (dev->CreateVertexBuffer(numverts*vertsize,D3DUSAGE_DONOTCLIP|D3DUSAGE_WRITEONLY,
			fvf,D3DPOOL_MANAGED,&verts,NULL)!=D3D_OK)
		{
			numverts=0;
			verts=NULL;
		}
	}
}

void VertexBufferD3D9::SetInterleaved(void *_data)
{
	register unsigned int i;
	char *data=(char *)_data;
	register unsigned int datavertsize=
		(vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)?
		vertsize-sizeof(DWORD)+sizeof(Vector4):
		vertsize;
	char *interleaved=new char[numverts*vertsize];

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		register unsigned int coordscoef=(vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)?2:1;
		for (i=0; i<numverts; i++)
		{
			memcpy(interleaved+vertsize*i,data+datavertsize*i,sizeof(Vector3)*coordscoef);
			
			DWORD *fvfcolor=(DWORD *)(interleaved+vertsize*i+sizeof(Vector3)*coordscoef);
			Vector4 *rcolor=(Vector4 *)(data+datavertsize*i+sizeof(Vector3)*coordscoef);
			*fvfcolor=D3DCOLOR_COLORVALUE(rcolor->x,rcolor->y,rcolor->z,rcolor->w);

			memcpy(interleaved+vertsize*i+sizeof(Vector3)*coordscoef+sizeof(DWORD),
				data+datavertsize*i+sizeof(Vector3)*coordscoef+sizeof(Vector4),
				sizeof(Vector2)*numtextures);
		}
	}
	else
	{
		memcpy(interleaved,data,vertsize*numverts);
	}

	void *vdata;
	if (verts->Lock(0,numverts*vertsize,&vdata,0)==D3D_OK)
	{
		memcpy(vdata,interleaved,numverts*vertsize);
		verts->Unlock();
	}
	else
		cerr<<"Could not lock vertex buffer for use!"<<endl;
}

void VertexBufferD3D9::Set(int type,int idx,void *_data)
{
	if (type==RAVEN_GEOMETRY_FLAG_INDICES)
	{
		void *idata;
		if (indices->Lock(0,numindices*4,&idata,0)==D3D_OK)
		{
			memcpy(idata,_data,numindices*4);
			indices->Unlock();
		}
		else
			cerr<<"Could not lock index buffer for use!"<<endl;
	}
	else
	{
		char *vdata;
		char *data=(char *)_data;
		
		if (verts->Lock(0,numverts*vertsize,(void **)&vdata,0)==D3D_OK)
		{
			register unsigned int i;
			switch (type)
			{
			case RAVEN_GEOMETRY_FLAG_VERTICES:
				for (i=0; i<numverts; i++)
					memcpy(vdata+vertsize*i,data+sizeof(Vector3)*i,sizeof(Vector3));
				break;
			case RAVEN_GEOMETRY_FLAG_NORMALS:
				for (i=0; i<numverts; i++)
					memcpy(vdata+vertsize*i+norm_offset,data+sizeof(Vector3)*i,sizeof(Vector3));
				break;
			case RAVEN_GEOMETRY_FLAG_COLORS:
				for (i=0; i<numverts; i++)
				{
					Vector4 *rcolor=(Vector4 *)(data+sizeof(Vector4)*i);
					DWORD *fvfcolor=(DWORD *)(vdata+vertsize*i+color_offset);
					*fvfcolor=D3DCOLOR_COLORVALUE(rcolor->x,rcolor->y,rcolor->z,rcolor->w);
				}
				break;
			case RAVEN_GEOMETRY_FLAG_TEXCOORDS:
				for (i=0; i<numverts; i++)
					memcpy(vdata+vertsize*i+tex_offset+sizeof(Vector2)*idx,data+sizeof(Vector2)*i,sizeof(Vector2));
			default:
				break;
			};
			verts->Unlock();
		}
		else
			cerr<<"Could not lock vertex buffer for use!"<<endl;
	}
}


static unsigned int prim_types[]=
{
	D3DPT_POINTLIST,
	D3DPT_LINELIST,
	D3DPT_LINESTRIP,
	0,
	D3DPT_TRIANGLELIST,
	D3DPT_TRIANGLESTRIP,
	D3DPT_TRIANGLEFAN,
	0,
	D3DPT_TRIANGLESTRIP
};

static unsigned int prim_count(unsigned int numverts,GeometryType geomtype)
{
	if (prim_types[geomtype])
	{
		switch (geomtype)
		{
		case RAVEN_GEOMETRY_POINTS:
			return numverts;
		case RAVEN_GEOMETRY_LINES:
			return numverts/2;
		case RAVEN_GEOMETRY_LINE_STRIP:
			return numverts-1;
		case RAVEN_GEOMETRY_TRIS:
			return numverts/3;
		case RAVEN_GEOMETRY_TRI_STRIP:
		case RAVEN_GEOMETRY_QUAD_STRIP:
		case RAVEN_GEOMETRY_TRI_FAN:
			return numverts-2;
		default:
			return 0;
		};
	}
	return 0;
}

bool VertexBufferD3D9::Render(GeometryType geomtype)
{
	unsigned int primtype=prim_types[geomtype];

	if (primtype)
	{
		dev->SetFVF(fvf);
		dev->SetStreamSource(0,verts,0,vertsize);
		if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES)
		{
			dev->SetIndices(indices);
			return dev->DrawIndexedPrimitive((D3DPRIMITIVETYPE)primtype,0,0,numverts,0,prim_count(numindices,geomtype))==D3D_OK;
		}
		else
			return dev->DrawPrimitive((D3DPRIMITIVETYPE)primtype,0,prim_count(numverts,geomtype))==D3D_OK;
	}
	else
		return false;
}