#include "test_vertex_shader.h"
#include "device/dvc_buffer_accessor.h"
#include "math/dvc_vector2.h"
#include "math/dvc_vector3.h"
#include "math/dvc_matrix4.h"
#include "device/dvc_uniform_buffer.h"

TestVertexShader::TestVertexShader()
{
	//output point v_position = point(0, 0, 0) [[ string attribute="POSITION"]],
	m_outputVertexDesc.addElement("v_position", davinci::VET_POSITION, davinci::CT_Float32, davinci::DT_Vec3);
	//output vector v_normal = vector(0,1,0) [[ string attribute="NORMAL"]],
	m_outputVertexDesc.addElement("v_normal", davinci::VET_NORMAL, davinci::CT_Float32, davinci::DT_Vec3);
	//output float v_uv[2] = {0, 0} [[ string attribute="TEXCOORD_0"]],
	m_outputVertexDesc.addElement("v_uv", davinci::VET_TEXCOORD_0, davinci::CT_Float32, davinci::DT_Vec2);
	//output vector v_toCamera = vector(0, 0, 0),
	m_outputVertexDesc.addElement("v_toCamera", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);
	//output vector v_toLight = vector(0,0,0)
	m_outputVertexDesc.addElement("v_toLight", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);

	m_outputVertexDesc.addElement("v_color0", davinci::VET_UNKNOWN, davinci::CT_Float32, davinci::DT_Vec3);
}

TestVertexShader::~TestVertexShader()
{

}

const char* TestVertexShader::getName(void) const
{
	return "test_vertex_shader";
}

size_t TestVertexShader::getOutputVertexByteSize(void) const
{
	return m_outputVertexDesc.vertexByteSize();
}

const davinci::VertexDesc& TestVertexShader::getOutputVertexDesc() const
{
	return m_outputVertexDesc;
}

void TestVertexShader::prepare(const davinci::UniformBuffer* uniformBuffer, SetInputAttributeFunc setInputAttributeFunc)
{
	m_uniformBuffer = uniformBuffer;

	//point a_position = vector(0, 0, 0) [[ string attribute="POSITION"]],
	m_POSITION = setInputAttributeFunc(davinci::VET_POSITION);
	//vector a_normal = vector(0, 1, 0) [[ string attribute="NORMAL"]],
	m_NORMAL = setInputAttributeFunc(davinci::VET_NORMAL);
	//float a_uv[2] = {0,0} [[ string attribute="TEXCOORD_0"]],
	m_TEXCOORD_0 = setInputAttributeFunc(davinci::VET_TEXCOORD_0);
	//
	m_COLOR_0 = setInputAttributeFunc(davinci::VET_COLOR_0);
}

void TestVertexShader::process(size_t index, void* outputVertex, davinci::fVector3& vertexWorldPos)
{
	static const float DEFAULT_POSITION[] = {0.f, 0.f, 0.f};
	static const float DEFAULT_NORMAL[] = { 0.f, 0.f, 0.f };
	static const float DEFAULT_TEXCOORD0[] = { 0.f, 0.f};
	static const uint16_t DEFAULT_COLOR0[] = { 0, 0, 0 };

	davinci::fVector3 a_position(m_POSITION ? (const float*)(m_POSITION->getElement(index)) : DEFAULT_POSITION);
	davinci::fVector3 a_normal(m_NORMAL ? (const float*)(m_NORMAL->getElement(index)) : DEFAULT_NORMAL);
	const float32_t* a_texcoord_0(m_TEXCOORD_0 ? (const float*)(m_TEXCOORD_0->getElement(index)) : DEFAULT_TEXCOORD0);
	const uint16_t* color0 = m_COLOR_0 ? (const uint16_t*)(m_COLOR_0->getElement(index)) : DEFAULT_COLOR0;

	davinci::fVector3 a_color_0(
		color0[0] / float(std::numeric_limits<uint16_t>::max()), 
		color0[1] / float(std::numeric_limits<uint16_t>::max()),
		color0[2] / float(std::numeric_limits<uint16_t>::max())
	);

	davinci::fMatrix4 mat_world = davinci::fMatrix4::IDENTITY;
	if (davinci::fMatrix4* p_mat_world = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("self:world_transform")))
	{
		mat_world = *p_mat_world;
	}

	davinci::fMatrix4 mat_camera_view_proj = davinci::fMatrix4::IDENTITY;
	if (davinci::fMatrix4* p_mat_camera_view_proj = (davinci::fMatrix4*)(m_uniformBuffer->getAttribute("camera:view_proj_mat")))
	{
		mat_camera_view_proj = *p_mat_camera_view_proj;
	}

	davinci::fVector3 camera_position = davinci::fVector3::ZERO;
	if (davinci::fVector3* p_camera_position = (davinci::fVector3*)(m_uniformBuffer->getAttribute("camera:eye_pos")))
	{
		camera_position = *p_camera_position;
	}

	davinci::fVector3 light0_position = davinci::fVector3::ZERO;
	if (davinci::fVector3* p_light0_position = (davinci::fVector3*)(m_uniformBuffer->getAttribute("light0:position")))
	{
		light0_position = *p_light0_position;
	}

	davinci::fVector3 temp1 = mat_world * a_position;
	davinci::fVector3 v_position = mat_camera_view_proj * temp1;

	davinci::fVector3 v_normal = a_normal;

	davinci::fVector3 v_color_0 = a_color_0;

	float32_t v_uv[2];
	memcpy(v_uv, a_texcoord_0, sizeof(float32_t) * 2);

	davinci::fVector3 v_to_camera = (camera_position - v_position).normalise();
	davinci::fVector3 v_to_light = (light0_position - v_position).normalise();

	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(0)->offset, &v_position, sizeof(davinci::fVector3));
	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(1)->offset, &v_normal, sizeof(davinci::fVector3));
	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(2)->offset, v_uv, sizeof(float32_t) * 2);
	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(3)->offset, &v_to_camera, sizeof(davinci::fVector3));
	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(4)->offset, &v_to_light, sizeof(davinci::fVector3));
	memcpy((char*)outputVertex + m_outputVertexDesc.getElement(5)->offset, &v_color_0, sizeof(davinci::fVector3));

	vertexWorldPos = mat_world * a_position;
}