#include "mesh.h"
#include "cglm/mat4.h"
#include "rendering.h"


CUtlVector<IMeshInstance*> g_meshes;
class CMeshInstance: public IMeshInstance
{
public:
	virtual void SetPosition( vec3 position ) override;
	virtual void SetRotationEuler( vec3 angle ) override;
	virtual void SetRotationQuat( vec4 quaternion) override;
	virtual void SetMatrix( mat4 matrix ) override;
	virtual void SetScale( vec3 scale ) override;

	virtual void Draw() override;

	mat4 m_matrix;
	vec3 m_position;
	
	IVertexBuffer *m_pVertexBuffer;
	IIndexBuffer *m_pIndexBuffer;
	
};
void CMeshInstance::SetPosition( vec3 position )
{
	glm_vec3_copy(position, m_position);

}

void CMeshInstance::SetRotationEuler( vec3 angle )
{

}

void CMeshInstance::SetRotationQuat( vec4 quaternion)
{

}

void CMeshInstance::SetMatrix( mat4 matrix )
{
	glm_mat4_copy(matrix, m_matrix);
}

void CMeshInstance::SetScale( vec3 scale )
{
}

void CMeshInstance::Draw()
{
	g_meshes.AppendTail(this);
}



class CMesh: public IMesh
{
public:
	virtual void SetVertexBuffer( IVertexBuffer *pBuffer ) override;
	virtual void SetIndexBuffer( IIndexBuffer *pBuffer ) override;

	virtual IMeshInstance *CreateInstance() override;

	IVertexBuffer *m_pVertexBuffer = 0;
	IIndexBuffer *m_pIndexBuffer = 0;
};

void CMesh::SetVertexBuffer( IVertexBuffer *pBuffer )
{
	m_pVertexBuffer = pBuffer;
}

void CMesh::SetIndexBuffer( IIndexBuffer *pBuffer )
{
	m_pIndexBuffer = pBuffer;
}

IMeshInstance *CMesh::CreateInstance()
{
	CMeshInstance *pInstance = new CMeshInstance;
	pInstance->m_pVertexBuffer = m_pVertexBuffer;
	pInstance->m_pIndexBuffer = m_pIndexBuffer;
	return pInstance;
};


IGraphicsPipeline *g_MeshPipeline;
class CMeshRendering: public IMeshRendering
{
	virtual void Init() override;
	virtual void Frame( float fDelta ) override;
	virtual void Deinit() override;
};
	
void CMeshRendering::Init()
{
	g_MeshPipeline = Renderer()->CreateGraphicsPipeline(
		{
		{"gfx/mesh_vert.shader", SHADER_TYPE_VERTEX},
		{"gfx/mesh_frag.shader", SHADER_TYPE_FRAGMENT},
		},
		{
			{SHADER_INPUT_TYPE_UNIFORM_BUFFER,0},
			{SHADER_INPUT_TYPE_TEXTURES,1},
		}, 
		80,
		20,
		{{0,0,EVertexFormat::VERTEX_FORMAT_X32Y32Z32}, {12,1,EVertexFormat::VERTEX_FORMAT_X32Y32}},
		{EImageFormat::IMAGE_FORMAT_R8G8B8A8},
		true
	);
}


void CMeshRendering::Frame( float fDelta )
{
	g_MeshPipeline->BindData(0, Renderer()->GetCameraMatrix(), 0);
	g_MeshPipeline->PushBindings();

	Renderer()->ResetState();
	Renderer()->SetDepthMode(DEPTH_MODE_LESS);
	Renderer()->BindPipeline(g_MeshPipeline);
	for (auto &v: g_meshes)
	{
		CMeshInstance *pMesh = (CMeshInstance*)v;
		struct {
			mat4 i;
			uint32_t a = 0;
			uint32_t b = 0;
			uint32_t c = 0;
		} constants;
		glm_mat4_copy(pMesh->m_matrix,constants.i);
		constants.i[3][0] = pMesh->m_position[0];
		constants.i[3][1] = pMesh->m_position[1];
		constants.i[3][2] = pMesh->m_position[2];
		Renderer()->SetConstants(sizeof(constants), &constants);
		Renderer()->Draw(pMesh->m_pVertexBuffer, pMesh->m_pIndexBuffer);
	}
	g_meshes = {};
}

void CMeshRendering::Deinit()
{

}
	
IMesh *IMeshRendering::CreateMesh()
{
	CMesh *pMesh = new CMesh;
	return pMesh;
};



DECLARE_MESH_RENDERING_STAGE(CMeshRendering, mesh_rendering)