/* -----------------------------------------------------------------------------
	GSFramework
	Copyright 2001-2013 Emmanuel Julien. All Rights Reserved.
----------------------------------------------------------------------------- */


		#include "gpu/gpu_material_shader.h"
		#include "gpu/gpu_material.h"
		#include "gpu/gpu_renderer.h"
		#include "log/log.h"

		using namespace GS;
		using namespace GS::GPU;
		using GS::NML::Tag;


//------------------------------------------------------------------------------
bool				MaterialShader::SetUserUniformValue(const char *name, const Vector4 &v)
{
	uint match_count = 0;
	for (uint n = 0; n < variants.GetCount(); ++n)
		if	(Shader *shader = variants[n].c_ptr())
			if	(ShaderInput *input = shader->GetInput(name))
			{
				input->parm_v = v;
				++match_count;
			}

	return match_count > 0;
}
bool				MaterialShader::SetUserUniformValue(const char *name, Render::Texture *t)
{
	uint match_count = 0;
	for (uint n = 0; n < variants.GetCount(); ++n)
		if	(Shader *shader = variants[n].c_ptr())
			if	(ShaderInput *input = shader->GetInput(name))
			{
				input->parm_t = t;
				++match_count;
			}

	return match_count > 0;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void				MaterialShader::CompileForwardPointLight(Core::Shader &shader, bool shadow)
{
	shader.Define("_POINT_LIGHT", Core::ShaderInput::Pixel);
	CompileShaderSection("OutputForwardLightModel", shader);

	if	(shadow)
	{
		shader.Define("_CAST_SHADOW", Core::ShaderInput::Pixel);

		shader.DeclareInput("psm", Core::ShaderInput::DataTextureShadow, Core::ShaderInput::LightShadowMap0, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		for	(int n = 0; n < 6; ++n)
			shader.DeclareInput(String::Format("psm_%d_projection_matrix", n), Core::ShaderInput::Matrix4, Core::ShaderInput::Semantic(Core::ShaderInput::LightShadowMatrix0 + n), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_iss", Core::ShaderInput::Float, Core::ShaderInput::InverseShadowMapSize, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_lsb", Core::ShaderInput::Float, Core::ShaderInput::LightShadowBias, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_vtl", Core::ShaderInput::Matrix4, Core::ShaderInput::ViewToLightMatrix, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_noise", Core::ShaderInput::DataTexture2D, Core::ShaderInput::NoiseMap, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);

		if	(Tag *t = renderer.GetPCFShaderTag())
			shader.pixel_decl += t->GetString();
		if	(Tag *t = renderer.GetPSMShaderTag())
			shader.pixel.Replace("%psm_pcf_evaluation%", t->GetString());
	}
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void				MaterialShader::CompileForwardSpotLight(Core::Shader &shader, bool shadow, bool projection_map)
{
	shader.Define("_SPOT_LIGHT", Core::ShaderInput::Pixel);
	CompileShaderSection("OutputForwardLightModel", shader);

	if	(shadow)
	{
		shader.Define("_CAST_SHADOW", Core::ShaderInput::Pixel);

		shader.DeclareInput("u_ssm", Core::ShaderInput::DataTextureShadow, Core::ShaderInput::Semantic(Core::ShaderInput::LightShadowMap0), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_ssm_projection", Core::ShaderInput::Matrix4, Core::ShaderInput::Semantic(Core::ShaderInput::LightShadowMatrix0), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_iss", Core::ShaderInput::Float, Core::ShaderInput::InverseShadowMapSize, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_lsb", Core::ShaderInput::Float, Core::ShaderInput::LightShadowBias, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_noise", Core::ShaderInput::DataTexture2D, Core::ShaderInput::NoiseMap, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);

		if	(Tag *t = renderer.GetPCFShaderTag())
			shader.pixel_decl += t->GetString();
	}

	if	(projection_map)
	{
		shader.Define("_PROJECTION_MAP", Core::ShaderInput::Pixel);
		shader.DeclareInput("u_pjm", Core::ShaderInput::DataTexture2D, Core::ShaderInput::Semantic(Core::ShaderInput::LightProjectionMap), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_pjm_projection", Core::ShaderInput::Matrix4, Core::ShaderInput::Semantic(Core::ShaderInput::LightShadowMatrix0), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
	}
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
void				MaterialShader::CompileForwardLinearLight(Core::Shader &shader, bool shadow)
{
	shader.Define("_LINEAR_LIGHT", Core::ShaderInput::Pixel);
	CompileShaderSection("OutputForwardLightModel", shader);

	if	(shadow)
	{
		shader.Define("_CAST_SHADOW", Core::ShaderInput::Pixel);

		shader.DeclareInput("pssm", Core::ShaderInput::DataTextureShadow, Core::ShaderInput::LightShadowMap0, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		for	(int n = 0; n < renderer.registry.GetInteger("ShadowMapping:PSSM:Split", 3); ++n)
		{
			shader.DeclareInput(String::Format("pssm_%d_slice_distance", n), Core::ShaderInput::Float, Core::ShaderInput::Semantic(Core::ShaderInput::LightPSSMSliceDistance0 + n), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
			shader.DeclareInput(String::Format("pssm_%d_projection_matrix", n), Core::ShaderInput::Matrix4, Core::ShaderInput::Semantic(Core::ShaderInput::LightShadowMatrix0 + n), Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		}
		shader.DeclareInput("u_noise", Core::ShaderInput::DataTexture2D, Core::ShaderInput::NoiseMap, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_iss", Core::ShaderInput::Float, Core::ShaderInput::InverseShadowMapSize, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.DeclareInput("u_lsb", Core::ShaderInput::Float, Core::ShaderInput::LightShadowBias, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);

		if	(Tag *t = renderer.GetPCFShaderTag())
			shader.pixel_decl += t->GetString();

		if	(Tag *t = renderer.GetPSSMShaderTag())
			shader.pixel.Replace("%pssm_pcf_evaluation%", t->GetString());
	}
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
bool				MaterialShader::CompileShaderSection(const char *id, Core::Shader &shader)
{
	Tag *shader_tag = renderer.GetMaterialDict().GetTag(id);
	if	(!shader_tag)
		__ERR__(__LOG_E__ << "Missing shader section '" << id << "'.\n", false)

	if	(Tag *tag = shader_tag->GetTag("Input;"))
		shader.ParseInputTag(tag);
	if	(Tag *tag = shader_tag->GetTag("Varying;"))
		shader.ParseVaryingTag(tag);
	if	(Tag *tag = shader_tag->GetTag("Vertex;"))
		shader.vertex += tag->GetString();
	if	(Tag *tag = shader_tag->GetTag("Fragment;"))
		shader.pixel += tag->GetString();

	return true;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
bool				MaterialShader::SetupMaterialProgram(Variant p, Core::Shader &shader)
{
	if	(parm.use_alpha_test)
	{
		shader.DeclareInput("u_alpha_threshold", Core::ShaderInput::Float, Core::ShaderInput::MaterialAlphaThreshold, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
		shader.pixel += "if (%opacity% < u_alpha_threshold) discard;\n";
	}

	if	(parm.use_depth_bias)
		shader.DeclareInput("u_depth_bias", Core::ShaderInput::Float, Core::ShaderInput::MaterialDepthBias, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);

	if	(parm.use_skinning)
	{
		shader.Define("_SKINNED", (Core::ShaderInput::Scope)(Core::ShaderInput::Vertex | Core::ShaderInput::Pixel));
		shader.DeclareInput("bone_mtx", Core::ShaderInput::Matrix4, Core::ShaderInput::BoneMatrix, Core::ShaderInput::Uniform, Core::ShaderInput::Vertex, __PL_BONE_LIMIT__);
		shader.DeclareInput("bone_idx", Core::ShaderInput::Vector4, Core::ShaderInput::BoneIndex, Core::ShaderInput::Attribute, Core::ShaderInput::Vertex);
		shader.DeclareInput("bone_w", Core::ShaderInput::Vector4, Core::ShaderInput::BoneWeight, Core::ShaderInput::Attribute, Core::ShaderInput::Vertex);
		shader.DeclareVarying("v_skin_mtx", "mat4");
	}

	CompileShaderSection("InputPosition;", shader);

	// Assemble program shader.
	switch (p)
	{
		case Depth:
			CompileShaderSection("OutputDepth;", shader);
			break;

		case FS_Constant:
			CompileShaderSection("OutputForwardConstant;", shader);
			break;

		case FS_PointLight:
		case FS_PointLightShadowMapping:
			CompileForwardPointLight(shader, p == FS_PointLightShadowMapping);
			break;

		case FS_SpotLight:
		case FS_SpotLightShadowMapping:
		case FS_SpotLightProjection:
		case FS_SpotLightProjectionShadowMapping:
			CompileForwardSpotLight(shader, (p == FS_SpotLightShadowMapping) || (p == FS_SpotLightProjectionShadowMapping), (p == FS_SpotLightProjection) || (p == FS_SpotLightProjectionShadowMapping));
			break;

		case FS_LinearLight:
		case FS_LinearLightShadowMapping:
			CompileForwardLinearLight(shader, p == FS_LinearLightShadowMapping);
			break;

		case DS_GBufferMRT4:
			CompileShaderSection("OutputDeferred;", shader);
			break;

		case PP_NormalDepth:
			CompileShaderSection("OutputNormalDepth;", shader);
			break;

		case PP_Velocity:
			if	(parm.use_skinning)
				shader.DeclareInput("previous_bone_mtx", Core::ShaderInput::Matrix4, Core::ShaderInput::PreviousBoneMatrix, Core::ShaderInput::Uniform, Core::ShaderInput::Vertex, __PL_BONE_LIMIT__);
			CompileShaderSection("OutputVelocity;", shader);
			break;

		case Last:
			break;
	}
	return true;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
static	bool		FindVarAssignation(const String &src, const char *var)	// TODO fix with proper regex, this is proof of concept code at best...
{
	if	(src.FindString(String::Format("%s =", var)))
		return true;
	if	(src.FindString(String::Format("%s\t=", var)))
		return true;

	return false;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
static void			DeclareVertexPosition(Core::Shader &shader, bool declare_varying)
{
	String decl = "vec4 %position%;\n";

	if	(!asbool(FindVarAssignation(shader.vertex, "%position%")))
	{
		Core::ShaderInput *input = shader.DeclareInput("a_position", Core::ShaderInput::Vector3, Core::ShaderInput::Position, Core::ShaderInput::Attribute, Core::ShaderInput::Vertex);
		// Core::ShaderInput *input = shader.GetInput(Core::ShaderInput::Position);
		decl << "%position% = vec4(" << input->name << ", 1.0);\n";
	}
	shader.vertex = decl + shader.vertex;
}
static void			DeclareVertexNormal(Core::Shader &shader)
{
	String decl = "vec3 %normal%;\n";

	if	(!asbool(FindVarAssignation(shader.vertex, "%normal%")))
	{
		Core::ShaderInput *input = shader.DeclareInput("a_normal", Core::ShaderInput::Vector3, Core::ShaderInput::Normal, Core::ShaderInput::Attribute, Core::ShaderInput::Vertex);
		// Core::ShaderInput *input = shader.GetInput(Core::ShaderInput::Normal);
		decl << "%normal% = " << input->name << ";\n";
	}
	shader.vertex = decl + shader.vertex;
}
static	void		InitializeShader(Core::Shader &shader)
{
	// Position
	{
		bool pixel_consumes = asbool(shader.pixel.FindString("%in.position%"));
		DeclareVertexPosition(shader, pixel_consumes);
	}

	// Normal
	{
		bool pixel_consumes = asbool(shader.pixel.FindString("%in.normal%"));
		bool pixel_provides = FindVarAssignation(shader.pixel, "%normal%");

		if	(pixel_consumes || !pixel_provides)
			DeclareVertexNormal(shader);

		if	(!pixel_provides)
			shader.pixel << "%normal% = %in.normal%;\n";

		shader.pixel = String("vec3 %normal%;\n") + shader.pixel;
	}

	{
		struct ShaderDefault
		{
			const char *type, *name, *var;
			Core::ShaderInput::DataType data_type;
			Core::ShaderInput::Semantic semantic;
		};

		static ShaderDefault ps_ic[] =
		{
			{ "vec4", "%diffuse%", "_u_mat_diff", Core::ShaderInput::Vector4, Core::ShaderInput::MaterialDiffuse },
			{ "vec4", "%specular%", "_u_mat_spec", Core::ShaderInput::Vector4, Core::ShaderInput::MaterialSpecular },
			{ "float", "%glossiness%", "_u_mat_glos", Core::ShaderInput::Float, Core::ShaderInput::MaterialGlossiness },
			{ "vec4", "%constant%", "_u_mat_const", Core::ShaderInput::Vector4, Core::ShaderInput::MaterialSelf },
			{ "float", "%opacity%", "_u_mat_opac", Core::ShaderInput::Float, Core::ShaderInput::MaterialOpacity },
			{ NULL, NULL, NULL }
		};

		// Declare mandatory outputs and set default value for unprovided entries.
		String decl;
		for (uint n = 0; ps_ic[n].type; ++n)
		{
			decl << ps_ic[n].type << " " << ps_ic[n].name << ";\n";

			if	(!FindVarAssignation(shader.pixel, ps_ic[n].name))
			{
				Core::ShaderInput *input = shader.DeclareInput(ps_ic[n].var, ps_ic[n].data_type, ps_ic[n].semantic, Core::ShaderInput::Uniform, Core::ShaderInput::Pixel);
				decl << ps_ic[n].name << " = " << input->name << ";\n";
			}
		}
		shader.pixel = decl + shader.pixel;
	}
}
static void			FinalizeShader(Core::Shader &shader)
{
	if	(asbool(shader.pixel.FindString("%in.position%")))
	{
		shader.DeclareVarying("_v_position", "vec4");
		shader.vertex << "_v_position = %position%;\n";
	}
	if	(asbool(shader.pixel.FindString("%in.normal%")))
	{
		shader.DeclareVarying("_v_normal", "vec3");
		shader.vertex << "_v_normal = %normal%;\n";
	}

	shader.pixel.ReplaceAll("%in.position%", "_v_position", true);
	shader.pixel.ReplaceAll("%in.normal%", "_v_normal", true);
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
static const char	*GetShaderVariantName(MaterialShader::Variant v)
{
	switch (v)
	{
		case MaterialShader::Depth:									return "Depth";

		case MaterialShader::DS_GBufferMRT4:						return "DS_GBufferMRT4";
		case MaterialShader::FS_Constant:							return "FS_Constant";

		case MaterialShader::FS_PointLight:							return "FS_PointLight";
		case MaterialShader::FS_PointLightShadowMapping:			return "FS_PointLightShadowMapping";

		case MaterialShader::FS_LinearLight:						return "FS_LinearLight";
		case MaterialShader::FS_LinearLightShadowMapping:			return "FS_LinearLightShadowMapping";

		case MaterialShader::FS_SpotLight:							return "FS_SpotLight";
		case MaterialShader::FS_SpotLightShadowMapping:				return "FS_SpotLightShadowMapping";
		case MaterialShader::FS_SpotLightProjection:				return "FS_SpotLightProjection";
		case MaterialShader::FS_SpotLightProjectionShadowMapping:	return "FS_SpotLightProjectionShadowMapping";

		case MaterialShader::PP_NormalDepth:						return "PP_NormalDepth";
		case MaterialShader::PP_Velocity:							return "PP_Velocity";

		case MaterialShader::Last:
			break;
	}
	return "UnknownVariant";
}
bool				MaterialShader::Create(Render::ResourceFactory &rf, const Core::Shader &shader, const MaterialShaderStaticParm &static_parm)
{
	__LOG_V__ << "Creating material shader '" << shader.name << "' variants.\n";

	name = shader.name;
	parm = static_parm;

	// Build variants.
	if	(!variants.Allocate(Last))
		return false;

	for	(int n = 0; n < Last; ++n)
	{
		if	(renderer.render_technique == Renderer::TechniqueDeferred)
			if	((n >= FS_Constant) && (n <= FS_SpotLightProjectionShadowMapping))
				continue;	// no forward

		if	(renderer.render_technique == Renderer::TechniqueForward)
			if	(n == DS_GBufferMRT4)
				continue;	// no deferred

		if	(!renderer.gpu_config.enable_shadow)
			if	(
					(n == Depth) ||
					(n == FS_PointLightShadowMapping) ||
					(n == FS_LinearLightShadowMapping) ||
					(n == FS_SpotLightShadowMapping) ||
					(n == FS_SpotLightProjectionShadowMapping)
				)
				continue;	// no shadow-mapping

		if	(!renderer.gpu_config.use_rtt)
			if	(
					(n == PP_Velocity) ||
					(n == PP_NormalDepth)
				)
				continue;	// no post-processes

		if	(parm.no_lighting)
			if	((n > FS_Constant) && (n <= FS_SpotLightProjectionShadowMapping))	// keep constant!
				continue;	// no lighting pass

		// Specialize shader for this program.
		Core::Shader shader_variant;
		if	(!shader.Clone(shader_variant))
			return false;

		InitializeShader(shader_variant);
		if	(!SetupMaterialProgram((Variant)n, shader_variant))
			return false;
		FinalizeShader(shader_variant);

		shader_variant.name << "_" << GetShaderVariantName((MaterialShader::Variant)n);

		// Compile it.
		if	((variants[n] = (Shader *)renderer.NewShader()) != NULL)
			if	(!variants[n]->Create(rf, shader_variant))
				return false;
	}
	return true;
}
//------------------------------------------------------------------------------

//------------------------------------------------------------------------------
MaterialShader::MaterialShader(Renderer &r) : renderer(r)
{	renderer.material_shaders.Add(this);	}
MaterialShader::~MaterialShader()
{	renderer.material_shaders.Remove(this);	}
//------------------------------------------------------------------------------