#include "vertexbuffer_vbo.h"

VertexBufferVBO::VertexBufferVBO(): VertexBuffer() {}
VertexBufferVBO::VertexBufferVBO(int attribs): VertexBuffer(attribs)
{
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES) glGenBuffersARB(1,&indices);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES) glGenBuffersARB(1,&verts);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS) glGenBuffersARB(1,&norms);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS) glGenBuffersARB(1,&colors);
}

VertexBufferVBO::~VertexBufferVBO()
{
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES) glDeleteBuffersARB(1,&indices);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES) glDeleteBuffersARB(1,&verts);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS) glDeleteBuffersARB(1,&norms);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS) glDeleteBuffersARB(1,&colors);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		if (numtextures)
		{
			for (register unsigned int i=0; i<numtextures; i++)
				glDeleteBuffersARB(1,texcoords+i);
			delete[] texcoords;
		}
	}
}

void VertexBufferVBO::NumIndices(unsigned int num) {numindices=num;}
unsigned int VertexBufferVBO::NumIndices() {return numindices;}
void VertexBufferVBO::NumVerts(unsigned int num) {numverts=num;}
unsigned int VertexBufferVBO::NumVerts() {return numverts;}

unsigned int VertexBufferVBO::NumTextures() {return numtextures;}
void VertexBufferVBO::NumTextures(unsigned int num)
{
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		if (num==0&&numtextures>0)
		{
			for (register unsigned int i=0; i<numtextures; i++)
				glDeleteBuffersARB(1,texcoords+i);
			delete[] texcoords;
		}
		else if (num>0&&numtextures==0)
		{
			texcoords=new GLuint[num];
			for (register unsigned int i=0; i<num; i++)
				glGenBuffersARB(1,texcoords+i);
		}
		else
		{
			for (register unsigned int i=0; i<numtextures; i++)
				glDeleteBuffersARB(1,texcoords+i);
			delete[] texcoords;
			texcoords=new GLuint[num];
			for (register unsigned int i=0; i<num; i++)
				glGenBuffersARB(1,texcoords+i);
		}
		numtextures=num;
	}
}

void VertexBufferVBO::SetInterleaved(void *data)
{
	char *bytes;
	VertexBuffer *buf=new VertexBuffer(vbufattribs&(~RAVEN_GEOMETRY_FLAG_INDICES));
	
	buf->NumVerts(numverts);
	buf->NumTextures(numtextures);

	buf->SetInterleaved(data);

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES)
	{
		buf->Get(RAVEN_GEOMETRY_FLAG_VERTICES,0,(void **)&bytes);
		this->Set(RAVEN_GEOMETRY_FLAG_VERTICES,0,(void *)bytes);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)
	{
		buf->Get(RAVEN_GEOMETRY_FLAG_NORMALS,0,(void **)&bytes);
		this->Set(RAVEN_GEOMETRY_FLAG_NORMALS,0,(void *)bytes);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		buf->Get(RAVEN_GEOMETRY_FLAG_COLORS,0,(void **)&bytes);
		this->Set(RAVEN_GEOMETRY_FLAG_COLORS,0,(void *)bytes);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		for (register unsigned int i=0; i<numtextures; i++)
		{
			buf->Get(RAVEN_GEOMETRY_FLAG_TEXCOORDS,i,(void **)&bytes);
			this->Set(RAVEN_GEOMETRY_FLAG_TEXCOORDS,i,(void *)bytes);
		}
	}

	delete buf;
}

void VertexBufferVBO::Set(int type,int idx,void *data)
{
	switch (type)
	{
	case RAVEN_GEOMETRY_FLAG_INDICES:
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,indices);
		glBufferDataARB(GL_ELEMENT_ARRAY_BUFFER_ARB,sizeof(unsigned int)*numindices,data,GL_STATIC_DRAW_ARB);
		break;
	case RAVEN_GEOMETRY_FLAG_VERTICES:
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,verts);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*3*numverts,data,GL_STATIC_DRAW_ARB);
		break;
	case RAVEN_GEOMETRY_FLAG_NORMALS:
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,norms);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*3*numverts,data,GL_STATIC_DRAW_ARB);
		break;
	case RAVEN_GEOMETRY_FLAG_COLORS:
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,colors);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*4*numverts,data,GL_STATIC_DRAW_ARB);
		break;
	case RAVEN_GEOMETRY_FLAG_TEXCOORDS:
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,texcoords[idx]);
		glBufferDataARB(GL_ARRAY_BUFFER_ARB,sizeof(float)*2*numverts,data,GL_STATIC_DRAW_ARB);
		break;
	};
}

void VertexBufferVBO::Get(int type,int idx,void **data) {*data=NULL;} // HW buffer; no retrieval for you!
unsigned int VertexBufferVBO::Size(int type) {return 0;}

static GLint geomtype_lookup[]=
{
	GL_POINTS,			//RAVEN_GEOMETRY_POINTS
	GL_LINES,			//RAVEN_GEOMETRY_LINES
	GL_LINE_STRIP,		//RAVEN_GEOMETRY_LINE_STRIP
	GL_LINE_LOOP,		//RAVEN_GEOMETRY_LINE_LOOP
	GL_TRIANGLES,		//RAVEN_GEOMETRY_TRIS
	GL_TRIANGLE_STRIP,	//RAVEN_GEOMETRY_TRI_STRIP
	GL_TRIANGLE_FAN,	//RAVEN_GEOMETRY_TRI_FAN
	GL_QUADS,			//RAVEN_GEOMETRY_QUADS
	GL_QUAD_STRIP		//RAVEN_GEOMETRY_QUAD_STRIP
};

// this is a hardware buffer, so we have a direct rendering function!
bool VertexBufferVBO::IsSoftBuffer() {return false;}
bool VertexBufferVBO::Render(GeometryType geomtype)
{
	glPushClientAttrib(GL_CLIENT_VERTEX_ARRAY_BIT);

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES) glEnableClientState(GL_VERTEX_ARRAY);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS) glEnableClientState(GL_NORMAL_ARRAY);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS) glEnableClientState(GL_COLOR_ARRAY);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS) glEnableClientState(GL_TEXTURE_COORD_ARRAY);

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES)
		glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB,indices);
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_VERTICES)
	{
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,verts);
		glVertexPointer(3,GL_FLOAT,0,NULL);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_NORMALS)
	{
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,norms);
		glNormalPointer(GL_FLOAT,0,NULL);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_COLORS)
	{
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,colors);
		glColorPointer(4,GL_FLOAT,0,NULL);
	}
	if (vbufattribs&RAVEN_GEOMETRY_FLAG_TEXCOORDS)
	{
		glBindBufferARB(GL_ARRAY_BUFFER_ARB,texcoords[0]);
		glTexCoordPointer(2,GL_FLOAT,0,NULL);
	}

	if (vbufattribs&RAVEN_GEOMETRY_FLAG_INDICES)
		glDrawElements(geomtype_lookup[geomtype],numindices,GL_UNSIGNED_INT,NULL);
	else
		glDrawArrays(geomtype_lookup[geomtype],0,numverts);

	glPopClientAttrib();

	return true;
}