#include "fs_classic_phong.h"
#include "asset/dvc_material.h"
#include "pipe/dvc_render_pipe.h"
#include "shader/dvc_shader_functions.h"

using namespace davinci;

const char* ClassicFragementShader_Phong::getName(void) const
{
	return "classic:phong";
}

bool ClassicFragementShader_Phong::begin(const davinci::RenderPipe* pipe, davinci::MaterialConstPtr material, const davinci::VertexDesc& veretexDesc)
{
	m_pipe = pipe;
	const davinci::UniformBuffer& uniformBuffer = m_pipe->getUniformBuffer();

	if(!(material->getParam("u_materialColor", m_materialColor)))
	{
		m_materialColor = davinci::fVector4::WHITE;
	}
	if(!(material->getParam("u_specularShininess", m_specularShininess)))
	{
		m_specularShininess = 64.0f;
	}
	if (!(material->getParam("u_specularStrength", m_specularStrength)))
	{
		m_specularStrength = 5.0f;
	}

	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("ambient_light:color")))
	{
		m_ambientLightColor = *attribute;
	}
	else
	{
		m_ambientLightColor = davinci::fVector3(0.2f, 0.2f, 0.2f);
	}

	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:position")))
	{
		m_light0Position = *attribute;
	}
	else return false;

	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("light0:color")))
	{
		m_light0Color = *attribute;
	}
	else return false;

	if (const davinci::fVector3* attribute = (davinci::fVector3*)(uniformBuffer.getAttribute("camera:eye_pos")))
	{
		m_cameraPosition = *attribute;
	}
	else return false;

	if (const VertexDesc::Element* element = veretexDesc.getElementByType(davinci::VET_POSITION_WORLD))
	{
		m_vWorldPosOffset = element->offset / sizeof(float32_t);
	}
	else return false;

	if (const VertexDesc::Element* element = veretexDesc.getElementByType(davinci::VET_NORMAL))
	{
		m_vNormalOffset = element->offset / sizeof(float32_t);
	}
	else return false;

	return true;
}

void ClassicFragementShader_Phong::process(const float32_t* pixelData, davinci::fVector4& color)
{
	fVector3 v_worldpos = *((const fVector3*)(pixelData + m_vWorldPosOffset));
	fVector3 v_normal = *((const fVector3*)(pixelData + m_vNormalOffset));

	fVector3 toLight = m_light0Position - v_worldpos;
	toLight.normalise();

	fVector3 toCamera = m_cameraPosition - v_worldpos;
	toCamera.normalise();

	float32_t ndotl = toLight.dotProduct(v_normal);
	fVector3 vR = 2 * ndotl*v_normal - toLight;
	float32_t rdotv = vR.dotProduct(toCamera);

	fVector3 colAmbient = m_ambientLightColor * m_materialColor.xyz();

	fVector3 colDiffuse = shader::max(0.0f, ndotl) * m_light0Color * m_materialColor.xyz();

	float32_t specular = shader::step(0.f, ndotl) * m_specularStrength *  shader::pow(shader::max(0.0f, rdotv), m_specularShininess);
	fVector3 colSpecular = specular * m_light0Color;

	fVector3 final = fVector3::BLACK;
	final += colAmbient;
	final += colDiffuse;
	final += colSpecular;

	color = fVector4(final.saturate(), 1.0f);
}

void ClassicFragementShader_Phong::end()
{
}