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


#ifndef	__NSHADER_BLOCK__
#define	__NSHADER_BLOCK__


		#include "core/shader.h"
		#include "color/color.h"
		#include "math/matrix3.h"
		#include "math/matrix4.h"
		#include "nstring/nstring.h"


namespace GS {
	namespace NML { class Tag; }

	namespace Core {
		struct ShaderBlockPin;
		struct ShaderBlock;

typedef	ShaderBlock * pShaderBlock;

/*!
	@short	Block shader value.
	Used by the raytracer software implementation of the shader blocks.
*/
struct	ShaderBlockValue
{
	enum BlockValueType
	{
		BlockValueNone		=	0,
		BlockValueVector,
		BlockValueMatrix3,
		BlockValueMatrix4,
		BlockValueTexture
	};

	BlockValueType type;

	// Can't union those and most of all we don't want runtime allocations here...
	Vector4		v;
	Matrix3		m3;
	Matrix4		m4;
	String		t;

	void		Set(const float &_f)
	{	v.x = _f; type = BlockValueVector;	}
	void		Set(const Vector4 &_v)
	{	v = _v;	type = BlockValueVector;	}
	void		Set(const Matrix3 &_m)
	{	m3 = _m; type = BlockValueMatrix3;	}
	void		Set(const Matrix4 &_m)
	{	m4 = _m; type = BlockValueMatrix4;	}

	void		Set(const char *_t)
	{	t = _t; type = BlockValueTexture;	}

	ShaderBlockValue() : type(BlockValueNone) {}
};

/*!
	@short	Base render block.

	A render block is a component of a render map. It represents an input, an
	operator to the	render map.

	@author	Emmanuel Julien (ejulien@gsworks.fr)
*/
struct	ShaderBlock
{
enum	BlockType
{
		TypeNone	=	0,

		// Input blocks.
		TypeGeometryVertex,
		TypeGeometryNormal,
		TypeGeometryUV,
		TypeGeometrySkinning,
		TypeGeometryVertexColor,
		TypeGeometryTangentFrame,
		TypeRenderBuffer,
		TypeTexture,
		TypeTextureSampler,
		TypeConstant,
		TypeColor,
		TypeMaterialParam,
		TypeMaterialTexture,
		TypeScreenUV,
		TypeViewVector,
		TypeViewport,

		// Matrix blocks.
		TypeNormalViewMatrix,
		TypeNormalMatrix,
		TypeModelViewMatrix,
		TypeModelMatrix,

		// Operator blocks.
		TypeMix,
		TypeAdd,
		TypeMul,
		TypeSub,
		TypeDiv,
		TypeDot,
		TypeCross,
		TypeClamp,
		TypeNormalize,
		TypeSwizzle,
		TypeBuild,
		TypeSin,
		TypeCos,
		TypePow,
		TypeAbs,

		// Packing operators.
		TypeUnpackColorToVector,
		TypePackVectorToColor,

		// Engine parameters.
		TypeClock,

		TypeInvalid
};

		/// Verbose block type.
static	const char		*BlockTypeToString(BlockType type)
		{
			switch (type)
			{
				case TypeNone:					return "None";
					 
				case TypeGeometryVertex:		return "Geometry Vertex";
				case TypeGeometryNormal:		return "Geometry Normal";
				case TypeGeometryUV:			return "Geometry UV";
				case TypeGeometrySkinning:		return "Geometry Skinning";
				case TypeGeometryVertexColor:	return "Geometry RGB";
				case TypeGeometryTangentFrame:	return "Geometry Tangent Frame";
				case TypeRenderBuffer:			return "Render Buffer";
				case TypeTexture:				return "Texture";
				case TypeTextureSampler:		return "Texture Sampler";
				case TypeConstant:				return "Constant";
				case TypeColor:					return "Color";
				case TypeMaterialParam:			return "Material Parameter";
				case TypeMaterialTexture:		return "Material Texture";
				case TypeScreenUV:				return "Screen UV";
				case TypeViewVector:			return "View Vector";
				case TypeViewport:				return "Viewport";
					 
				case TypeNormalViewMatrix:		return "Normal View Matrix";
				case TypeNormalMatrix:			return "Normal Matrix ";	///< ! The additional space is NEEDED! (Normal matrix is the name of a legacy version of this node)
				case TypeModelViewMatrix:		return "Model View Matrix";
				case TypeModelMatrix:			return "Model Matrix";
					 
				case TypeMix:					return "Mix";
				case TypeAdd:					return "Add";
				case TypeMul:					return "Multiply";
				case TypeSub:					return "Subtract";
				case TypeDiv:					return "Divide";
				case TypeDot:					return "Dot";
				case TypeCross:					return "Cross";
				case TypeClamp:					return "Clamp";
				case TypeNormalize:				return "Normalize";
				case TypeSwizzle:				return "Swizzle";
				case TypeBuild:					return "Build";
				case TypeSin:					return "Sinus";
				case TypeCos:					return "Cosinus";
				case TypePow:					return "Pow";
				case TypeAbs:					return "Abs";
					 
				case TypeUnpackColorToVector:	return "Unpack color to vector";
				case TypePackVectorToColor:		return "Pack vector to color";
					 
				case TypeClock:					return "Clock";
					 
				case TypeInvalid:				break;
			}
			return "Invalid";
		}

		Vector2		pos;
		BlockType		type;

/*
	@name	Block input/output.
	@{
*/
		/// Get input count.
virtual	uint			GetInputCount() const = 0;
		/// Get input block.
virtual	ShaderBlock		*GetInput(uint n) const = 0;
		/// Set input.
virtual	bool			SetInput(uint n, ShaderBlock *in) = 0;

		/// Get input pin.
virtual	const ShaderBlockPin *GetInputPin(uint n) const = 0;
		/// Get block output pin.
virtual	const ShaderBlockPin *GetOutputPin() const = 0;

		/// Evaluate block output type.
virtual	int				GetOutputType() const = 0;
/// @}

		/// Get block label.
virtual	String			GetLabel() const = 0;
		/// Get block id.
virtual	String			GetId() const = 0;

		/// Is this block equivalent to another block.
		bool			IsEquivalent(const ShaderBlock *input_block) const;

		/// Gather all of this block children.
		void			GatherChildren(List <ShaderBlock *> &children);

		/// Import block map from metatag.
static	Array <pShaderBlock> *BlockMapFromMetaTag(NML::Tag &);
		/// Import branch from metatag.
static	ShaderBlock		*BranchFromMetaTag(NML::Tag &, Array <pShaderBlock> *block_map = 0);

static	NML::Tag		*BlockMapAsMetaTag(const List <ShaderBlock *> &block_map);
		NML::Tag		*BranchAsMetaTag(List <ShaderBlock *> &block_map);
		NML::Tag		*ParamAsMetaTag() const;

		ShaderBlock() : type(TypeNone) {}
virtual	~ShaderBlock() {}
};

//------------------------------------------------------------------------------
#define		__SpecializeBlock(__LABEL__, __INPUT_COUNT__)\
static	ShaderBlockPin	input_pin[__INPUT_COUNT__];\
static	ShaderBlockPin	output_pin;\
		\
		ShaderBlock		*input[__INPUT_COUNT__];\
		\
		String			GetLabel() const\
		{	return __LABEL__;	}\
		uint			GetInputCount() const\
		{	return __INPUT_COUNT__;	}\
		bool			SetInput(uint n, ShaderBlock *block)\
		{\
			if	(n >= __INPUT_COUNT__)\
				return false;\
			if	(block && !(input_pin[n].compatibility & block->GetOutputType()))\
				return false;\
			input[n] = block;\
			return true;\
		}\
		ShaderBlock	*GetInput(uint n) const\
		{	return (n < __INPUT_COUNT__) ? input[n] : 0;	}\
		const ShaderBlockPin *GetInputPin(uint n) const\
		{	return (n < __INPUT_COUNT__) ? &input_pin[n] : 0;	}\
		const ShaderBlockPin *GetOutputPin() const\
		{	return &output_pin;	}\
		int				GetOutputType() const;

#define		__SpecializeBlockNoInput(__LABEL__)\
static	ShaderBlockPin	output_pin;\
		\
		String			GetLabel() const\
		{	return __LABEL__;	}\
		uint			GetInputCount() const\
		{	return 0;	}\
		bool			SetInput(uint /*n*/, ShaderBlock */*block*/)\
		{	return false;	}\
		ShaderBlock		*GetInput(uint /*n*/) const\
		{	return 0;	}\
		const ShaderBlockPin *GetInputPin(uint /*n*/) const\
		{	return 0;	}\
		const ShaderBlockPin *GetOutputPin() const\
		{	return &output_pin;	}\
		int				GetOutputType() const;

//------------------------------------------------------------------------------

/*
	@short	Render block pin description.
	@author	Emmanuel Julien (ejulien@gsworks.fr)
*/
struct	ShaderBlockPin
{
		const char		*name,
						*desc;
		int				compatibility;		///< Pin connection compatibility
};

struct	SinusShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Sinus", 1)

		String			GetId() const
		{	return "Sin";	}
		SinusShaderBlock(ShaderBlock *block = 0)
		{
			type = TypeSin;
			input[0] = block;
		}
};

struct	CosinusShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Cosinus", 1)

		String			GetId() const
		{	return "Cos";	}
		CosinusShaderBlock(ShaderBlock *block = 0)
		{
			type = TypeCos;
			input[0] = block;
		}
};

struct	PowShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Pow", 2)

		String			GetId() const
		{	return "Pow";	}
		PowShaderBlock(ShaderBlock *v = 0, ShaderBlock *p = 0)
		{
			type = TypePow;
			input[0] = v;
			input[1] = p;
		}
};

struct	AbsShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Abs", 1)

		String			GetId() const
		{	return "Abs";	}
		AbsShaderBlock(ShaderBlock *v = 0)
		{
			type = TypeAbs;
			input[0] = v;
		}
};

struct	ClockShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Clock")

		String			GetId() const
		{	return "Clock";	}
		ClockShaderBlock()
		{	type = TypeClock;	}
};

struct	ScreenUVShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Screen UV")

		String			GetId() const
		{	return "ScreenUV";	}
		ScreenUVShaderBlock()
		{	type = TypeScreenUV;	}
};

struct	ViewVectorShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("View Vector")

		String			GetId() const
		{	return "ViewV";	}
		ViewVectorShaderBlock()
		{	type = TypeViewVector;	}
};

struct	ViewportShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Viewport")

		String			GetId() const
		{	return "Viewport";	}
		ViewportShaderBlock()
		{	type = TypeViewport;	}
};

struct	NormalViewMatrixShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Normal View Matrix")

		String			GetId() const
		{	return "NormalViewMatrix";	}
		NormalViewMatrixShaderBlock()
		{	type = TypeNormalViewMatrix;	}
};

struct	NormalMatrixShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Normal Matrix ")

		String			GetId() const
		{	return "NormalMatrix";	}
		NormalMatrixShaderBlock()
		{	type = TypeNormalMatrix;	}
};

struct	ModelViewMatrixShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Model View Matrix ")

		String			GetId() const
		{	return "ModelViewMatrix";	}
		ModelViewMatrixShaderBlock()
		{	type = TypeModelViewMatrix;	}
};

struct	ModelMatrixShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Model Matrix")

		String			GetId() const
		{	return "ModelMatrix";	}
		ModelMatrixShaderBlock()
		{	type = TypeModelMatrix;	}
};

struct	UnpackColorToVectorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Unpack Color", 1)

		String			GetId() const
		{	return "UnpackColor";	}
		UnpackColorToVectorShaderBlock(ShaderBlock *block = 0)
		{
			type = TypeUnpackColorToVector;
			input[0] = block;
		}
};

struct	PackVectorToColorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Pack Vector", 1)

		String			GetId() const
		{	return "PackVector";	}
		PackVectorToColorShaderBlock(ShaderBlock *block = 0)
		{
			type = TypePackVectorToColor;
			input[0] = block;
		}
};

struct	MixOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Mix", 3)

		String			GetId() const
		{	return "Mix";	}
		MixOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0, ShaderBlock *k = 0)
		{
			type = TypeMix;
			input[0] = a; input[1] = b; input[2] = k;
		}
};

struct	AddOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Add", 2)

		String			GetId() const
		{	return "Add";	}
		AddOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeAdd;
			input[0] = a; input[1] = b;
		}
};

struct	MulOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Mul", 2)

		String			GetId() const
		{	return "Mul";	}
		MulOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeMul;
			input[0] = a; input[1] = b;
		}
};

struct	SubOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Sub", 2)

		String			GetId() const
		{	return "Sub";	}
		SubOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeSub;
			input[0] = a; input[1] = b;
		}
};

struct	DivOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Div", 2)

		String			GetId() const
		{	return "Div";	}
		DivOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeDiv;
			input[0] = a; input[1] = b;
		}
};

struct	DotOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Dot", 2)

		String			GetId() const
		{	return "Dot";	}
		DotOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeDot;
			input[0] = a; input[1] = b;
		}
};

struct	CrossOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Cross", 2)

		String			GetId() const
		{	return "Cross";	}
		CrossOperatorShaderBlock(ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeCross;
			input[0] = a; input[1] = b;
		}
};

struct	NormalizeOperatorShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Normalize", 1)

		String			GetId() const
		{	return "Norm";	}
		NormalizeOperatorShaderBlock(ShaderBlock *a = 0)
		{
			type = TypeNormalize;
			input[0] = a;
		}
};

struct	ClampShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Clamp", 3)

		String			GetId() const
		{	return "Clamp";	}
		ClampShaderBlock(ShaderBlock *v = 0, ShaderBlock *a = 0, ShaderBlock *b = 0)
		{
			type = TypeClamp;
			input[0] = v; input[1] = a; input[2] = b;
		}
};

struct	SwizzleShaderBlock : public ShaderBlock
{
enum	Swizzle
{
	SwizzleNone	= 0,
	SwizzleX,
	SwizzleY,
	SwizzleZ,
	SwizzleW
};

		__SpecializeBlock("Swizzle", 1)

		String			GetId() const
		{	return String::Format("Swizzle%d%d%d%d", swizzle[0], swizzle[1], swizzle[2], swizzle[3]);	}
		Swizzle			swizzle[4];
		SwizzleShaderBlock(ShaderBlock *block = 0, Swizzle x = SwizzleNone, Swizzle y = SwizzleNone, Swizzle z = SwizzleNone, Swizzle w = SwizzleNone)
		{
			type = TypeSwizzle;
			swizzle[0] = x; swizzle[1] = y; swizzle[2] = z; swizzle[3] = w;
			input[0] = block;
		}
};

struct	BuildShaderBlock : public ShaderBlock
{
enum	Build
{
	BuildZero	= 0,
	BuildOne,
	BuildX,
	BuildY,
	BuildZ,
	BuildW
};

		__SpecializeBlock("Build", 4)

		Build			build[4];
		String			GetId() const
		{	return String::Format("Build%d%d%d%d", build[0], build[1], build[2], build[3]);	}
		BuildShaderBlock(ShaderBlock *a = 0, Build x = BuildX, ShaderBlock *b = 0, Build y = BuildY, ShaderBlock *c = 0, Build z = BuildZ, ShaderBlock *d = 0, Build w = BuildW)
		{
			type = TypeBuild;
			build[0] = x; build[1] = y; build[2] = z; build[3] = w;
			input[0] = a; input[1] = b; input[2] = c; input[3] = d;
		}
};

struct	GeometryUVShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("UV Stream")

		int				channel;
		String			GetId() const
		{	return String::Format("UV%d", channel);	}

		GeometryUVShaderBlock(int uv_channel = 0)
		{
			type = TypeGeometryUV;
			channel = uv_channel;
		}
};

struct  GeometryVertexShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Vertex Stream")

		String			GetId() const
		{	return String("Vertex");	}

		GeometryVertexShaderBlock()
		{	type = TypeGeometryVertex;	}
};

struct	GeometryNormalShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Normal Stream")

		bool			smooth;
		String			GetId() const
		{	return String(smooth ? "NormalSmooth" : "Normal");	}

		GeometryNormalShaderBlock()
		{
			type = TypeGeometryNormal;
			smooth = true;
		}
};

struct	GeometrySkinningShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Skinning Matrix")

		String			GetId() const
		{	return String("SkinMtx");	}

		GeometrySkinningShaderBlock()
		{	type = TypeGeometrySkinning;	}
};

struct	GeometryVertexColorShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Vertex Color Stream")

		String			GetId() const
		{	return String("VertexColor");	}
		GeometryVertexColorShaderBlock()
		{	type = TypeGeometryVertexColor;	}
};

struct	GeometryTangentFrameShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Tangent Frame")

		String			GetId() const
		{	return String("TangentMtx");	}

		GeometryTangentFrameShaderBlock()
		{	type = TypeGeometryTangentFrame;	}
};

struct	RenderBufferShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Render Buffer")

enum	RenderBuffer
{
	Depth	=	0
};

		RenderBuffer	buffer;
		String			GetId() const
		{	return String("RenderBuffer");	}

		RenderBufferShaderBlock(RenderBuffer _buffer = Depth)
		{
			type = TypeRenderBuffer;
			buffer = _buffer;
		}
};

struct	TextureShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Texture")

		enum TextureType
		{
			Texture2D	=	0,
			Texture3D,
			TextureCube
		};
		TextureType		texture_type;

		String			texture;
		String			GetId() const;

		TextureShaderBlock(const char *name = 0)
		{
			type = TypeTexture;
			texture = name;
			texture_type = Texture2D;
		}
};

struct	TextureSamplerShaderBlock : public ShaderBlock
{
		__SpecializeBlock("Texture Sampler", 2)

		enum SamplerType
		{
			Sampler2D	=	0,
			Sampler3D,
			SamplerCube
		};
		SamplerType		sampler_type;

		String			GetId() const
		{	return String::Format("TexSampler%d", (int)sampler_type);	}

		TextureSamplerShaderBlock(ShaderBlock *texture = 0, ShaderBlock *uv = 0)
		{
			type = TypeTextureSampler;

			sampler_type = Sampler2D;
			input[0] = texture;
			input[1] = uv;
		}
};

struct	MaterialParamShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Material Parameter")

enum	MaterialParam
{
	MaterialDiffuse	= 0,
	MaterialSpecular,
	MaterialSelf,
	MaterialAmbient,
	MaterialGlossiness,
	MaterialOpacity,
	MaterialReflection
};

		MaterialParam	param;

		String			GetId() const;
		MaterialParamShaderBlock(MaterialParam p = MaterialDiffuse)
		{
			type = TypeMaterialParam;
			param = p;
		}
};

struct	MaterialTextureShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Material Texture")

		enum TextureType
		{
			Texture2D	=	0,
			Texture3D,
			TextureCube
		};
		TextureType		texture_type;
		int				slot;

		String			GetId() const;

		MaterialTextureShaderBlock(int n = 0)
		{
			type = TypeMaterialTexture;
			texture_type = Texture2D;
			slot = n;
		}
};

struct	ColorShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Color")

		Color			color;

		String			GetId() const
		{	return "Color";	}

		ColorShaderBlock(float r = 1, float g = 1, float b = 1, float a = 1)
		{
			type = TypeColor;
			color.Set(r, g, b, a);
		}
};

struct	ConstantShaderBlock : public ShaderBlock
{
		__SpecializeBlockNoInput("Constant")

		float			constant[4];
		ShaderInput::DataType constant_type;
		String			GetId() const;

		ConstantShaderBlock()
		{
			type = TypeConstant; constant_type = ShaderInput::NoData;
			constant[0] = constant[1] = constant[2] = constant[3] = 0;
		}
		ConstantShaderBlock(float v)
		{
			type = TypeConstant; constant_type = ShaderInput::Float;
			constant[0] = v; constant[1] = constant[2] = constant[3] = 0;
		}
		ConstantShaderBlock(float u, float v)
		{
			type = TypeConstant; constant_type = ShaderInput::Vector2;
			constant[0] = u; constant[1] = v; constant[2] = constant[3] = 0;
		}
		ConstantShaderBlock(float x, float y, float z)
		{
			type = TypeConstant; constant_type = ShaderInput::Vector3;
			constant[0] = x; constant[1] = y; constant[2] = z; constant[3] = 0;
		}
		ConstantShaderBlock(float x, float y, float z, float w)
		{
			type = TypeConstant; constant_type = ShaderInput::Vector4;
			constant[0] = x; constant[1] = y; constant[2] = z; constant[3] = w;
		}
};

	} // Core
} // GS


#endif	// __NSHADER_BLOCK__