// the variable m_hardwarebufferdata that I'm using is an instance of this struct:
typedef struct {
	D3DVERTEXBUFFERDESC		desc;
	IDirect3DVertexBuffer7*	source;
	IDirect3DVertexBuffer7*	target;
	int						vertexcount;
	VertexBuffer*			vb;
} ENGINE_RENDERER_DIRECT3D_HWB;



void RendererEngine_Direct3D::SetHVBData(int vertexbuffer)
{
	m_hardwarebufferdata = (ENGINE_RENDERER_DIRECT3D_HWB*)vertexbuffer;
}

void RendererEngine_Direct3D::DrawHVBTriangles(unsigned int start_index, unsigned int triangle_count)
{
	m_d3ddevice->DrawPrimitiveVB(m_rendermode, m_hardwarebufferdata->target, start_index, triangle_count*3, NULL);
}

void RendererEngine_Direct3D::DrawHVBIndexed(unsigned int indices_count, ENGINE_RENDERER_ARRAY_INDICES indices)
{
	m_d3ddevice->DrawIndexedPrimitiveVB(m_rendermode, m_hardwarebufferdata->target, 0, m_hardwarebufferdata->vertexcount, indices, indices_count, NULL);
}

/** Vertex buffer commands */

int RendererEngine_Direct3D::CreateHardwareVertexBuffer(VertexBuffer* vb)
{
	// create struct
	ENGINE_RENDERER_DIRECT3D_HWB* hwb = (ENGINE_RENDERER_DIRECT3D_HWB*)AXEMALLOC(sizeof(ENGINE_RENDERER_DIRECT3D_HWB));
	memset(hwb, 0, sizeof(ENGINE_RENDERER_DIRECT3D_HWB));
	hwb->vb = vb;
	hwb->vertexcount = vb->GetVertexCount();

	// setup vertex buffer descriptor
	ZeroMemory(&hwb->desc, sizeof(D3DVERTEXBUFFERDESC));
	hwb->desc.dwSize		= sizeof(D3DVERTEXBUFFERDESC);
	hwb->desc.dwCaps		= D3DVBCAPS_WRITEONLY;
	hwb->desc.dwFVF			= m_vertexformat;
	hwb->desc.dwNumVertices	= vb->GetVertexCount();

	// try to create the buffer in Direct3D
	if (FAILED(m_d3d->CreateVertexBuffer(&hwb->desc, &hwb->source, 0L))) {
		return -1;
	}

	// lock buffer, fill it, unlock it
	void* bufferdata;
	DWORD buffersize;
	if (FAILED(hwb->source->Lock(DDLOCK_WAIT | DDLOCK_WRITEONLY, &bufferdata, &buffersize))) {
		ENGINE_LOG(("createhardwarevertexbuffer: failed to lock vertex buffer"));
		hwb->source->Release();
		AXEFREE(hwb);
		return -1;
	}
	unsigned int totalsize = hwb->vertexcount*(sizeof(float) * (3 + 3 + 2*m_texturecount));
	if (totalsize != buffersize) {
		ENGINE_LOG(("createhardwarevertexbuffer: invalid vertex buffer size (it's %d, we need %d): is the multitexture count correctly set?", buffersize, totalsize));
		hwb->source->Unlock();
		hwb->source->Release();
		AXEFREE(hwb);
		return -1;
	}
	memcpy(bufferdata, vb->GetBuffer(), totalsize);
	hwb->source->Unlock();

	// optimize buffer for the current device
	hwb->source->Optimize(m_d3ddevice, NULL);

	// create target buffer, which will contain the transformed, processed vertices
	ASSERT(m_texturecount>0, ("CreateHardwareVertexBuffer: m_texturecount is %d", m_texturecount));
	hwb->desc.dwFVF = D3DFVF_XYZRHW | (D3DFVF_TEX1 * m_texturecount);
	if (FAILED(m_d3d->CreateVertexBuffer(&hwb->desc, &hwb->target, 0L))) {
		hwb->source->Release();
		AXEFREE(hwb);
		return -1;
	}
	
	// return pointer to our hardware vertex buffer struct converted to int
	return (int)hwb;
}

void RendererEngine_Direct3D::ProcessHardwareVertexBuffer(int vertexbuffer)
{
	FUNCCALL_COUNTER(m_funccall_processhvb);
	// for performance reasons, we're not checking the input
	ENGINE_RENDERER_DIRECT3D_HWB* hwb = (ENGINE_RENDERER_DIRECT3D_HWB*)vertexbuffer;
	if FAILED(hwb->target->ProcessVertices(D3DVOP_TRANSFORM, 0, hwb->vertexcount, hwb->source, 0, m_d3ddevice, 0)) {
		ENGINE_LOG(("processhardwarevertexbuffer: ProcessVertices failed"));
	}
}

void RendererEngine_Direct3D::DestroyHardwareVertexBuffer(int vertexbuffer)
{
	ENGINE_RENDERER_DIRECT3D_HWB* hwb = (ENGINE_RENDERER_DIRECT3D_HWB*)vertexbuffer;
	if (hwb) {
		if (hwb->source) hwb->source->Release();
		if (hwb->target) hwb->target->Release();
		AXEFREE(hwb);
	}
}