// NeL - MMORPG Framework <http://dev.ryzom.com/projects/nel/>
// Copyright (C) 2010  Winch Gate Property Limited
//
// This program is free software: you can redistribute it and/or modify
// it under the terms of the GNU Affero General Public License as
// published by the Free Software Foundation, either version 3 of the
// License, or (at your option) any later version.
//
// This program is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
// GNU Affero General Public License for more details.
//
// You should have received a copy of the GNU Affero General Public License
// along with this program.  If not, see <http://www.gnu.org/licenses/>.

#ifndef NL_PS_ATTRIB_MAKER_TEMPLATE_H
#define NL_PS_ATTRIB_MAKER_TEMPLATE_H

#include "nel/misc/types_nl.h"
#include "nel/3d/ps_attrib_maker_helper.h"
#include "nel/3d/ps_plane_basis.h"
#include "nel/misc/fast_floor.h"
#include "nel/misc/rgba.h"
#include "nel/misc/traits_nl.h"

#include <iterator>

namespace NL3D {

/*
 *	In this file, we define several template that helps to create attributes maker such as gradient (of float, int, vector etc)
 * attributes maker are used in the particle system to generate values, such as size, color etc. see ps_attrib_maker.h
 * for more information
 */




/** a blending function
 * it blends between t1 and t2 by the alpha amount
 * specializing this function may help with some types of data that don't have the needed operator (NLMISC::CRGBA)
 */

template <typename T>
inline T PSValueBlend(const T &t1, const T &t2, float alpha)
{
	return T(alpha * t2 + (1.f - alpha) * t1);
}


/// NLMISC::CRGBA specialization of the PSValueBlend function
inline NLMISC::CRGBA PSValueBlend(const NLMISC::CRGBA &t1, const NLMISC::CRGBA &t2, float alpha)
{
	NLMISC::CRGBA result;
	result.blendFromui(t1, t2, (uint) (255.0f * alpha));
	return result;
}


/// CPlaneBasis specilization of the PSValueBlend function
inline CPlaneBasis PSValueBlend(const CPlaneBasis &t1, const CPlaneBasis &t2, float alpha)
{
	return CPlaneBasis(PSValueBlend(t1.getNormal(), t2.getNormal(), alpha));
}


/// Base struct for blending function (exact or sampled)
template <typename T> struct CPSValueBlendFuncBase
{
	virtual ~CPSValueBlendFuncBase() {}
	virtual void getValues(T &startValue, T &endValue) const = 0;
	virtual void setValues(T startValue, T endValue) = 0;
};



/**
 * This temlate functor blend exactly between 2 value (no samples)
 * To accomplish blending, it use the template function PSValueBlend
 * It is used by CPSValueBlend
 * \author Nicolas Vizerie
 * \author Nevrax France
 * \date 2001
 * \see PSValueBlend
 */
template <typename T> class CPSValueBlendFunc : public CPSValueBlendFuncBase<T>
{
public:
	/// \name Object
	//@{
		/// ctor
		CPSValueBlendFunc() {}

		/// serialization
		void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
		{
			f.serialVersion(1);
			f.serial(_StartValue, _EndValue);
		}
	//@}

	/// This produce Values
	#ifdef NL_OS_WINDOWS
		__forceinline
	#endif
	T operator()(TAnimationTime time) const
	{

		#ifdef NL_DEBUG
			nlassert(time >= 0.f && time <= 1.f);
		#endif
		return PSValueBlend(_StartValue, _EndValue, time);	// a cast to T is necessary, because
														// the specialization could be done with integer
	}

	/// \Name Values that are blended
	//@{
		/// Retrieve the start and end Value
		virtual void getValues(T &startValue, T &endValue) const
		{
			startValue = (*this)(0);
			endValue = (*this)(1);
		}

		/// Set the Values between which to blend.
		virtual void setValues(T startValue, T endValue)
		{
			_StartValue = startValue;
			_EndValue = endValue;
		}

		///
		T getMaxValue(void) const
		{
			return std::max((*this)(0), (*this)(1));
		}
		T getMinValue(void) const
		{
			return std::min((*this)(0), (*this)(1));
		}
	//@}

protected:
	T _StartValue, _EndValue;
};


/** This is a Value blender class. The blending between value is not sampled with this class.
  *  So it may be slow, but it is exact.
  *  It work with most type, but some of them may need special  blending between value :
  *  if so you must specialize the template function PSValueBlend defined in this file
  *  to do the job...
  *  To use this, just derive a class, create a ctor, and declare it to the class registry
  *
  *  in the ctor, you should call _F.setValue to init the functor object.
  */

template <typename T> class CPSValueBlender : public CPSAttribMakerT<T, CPSValueBlendFunc<T> >
{
public:
	/** ctor
	 *  With nbCycles, you can set the pattern frequency. It is usually one. See ps_attrib_maker.h
	 *  For further details
	 */
	CPSValueBlender(float nbCycles) : CPSAttribMakerT<T, CPSValueBlendFunc<T> >(nbCycles)
	{
	}

	virtual T getMaxValue(void) const { return this->_F.getMaxValue(); }
	virtual T getMinValue(void) const { return this->_F.getMinValue(); }

	// serialization is done by CPSAttribMakerT
};




/**
 * This temlate functor blend between 2 values by performing n samples (n = template parameter)
 * It may be faster that the CPSValueBlendFunc in some cases.
 * To accomplish blending, it use the template function PSValueBlend
 * It is used by CPSValueBlend
 * \author Nicolas Vizerie
 * \author Nevrax France
 * \date 2001
 * \see PSValueBlend
 */

template <typename T, const uint n> class CPSValueBlendSampleFunc : public CPSValueBlendFuncBase<T>
{
public:
	/// this produce Values
	#ifdef NL_OS_WINDOWS
			__forceinline
	#endif
	T operator()(TAnimationTime time) const
	{
		#ifdef NL_DEBUG
			nlassert(time >= 0.f && time <= 1.f);
		#endif
		return _Values[NLMISC::OptFastFloor(time * n)];
	}

	/// restrieve the start and end Value

	virtual void getValues(T &startValue, T &endValue) const
	{
		startValue = _Values[0];
		endValue = _Values[n];
	}

	/// set the Values

	virtual void setValues(T startValue, T endValue)
	{
		float step = 1.f / n;
		float alpha = 0.0f;
		for (uint k = 0; k < n; ++k)
		{
			_Values[k] = PSValueBlend(startValue, endValue, alpha);
			alpha += step;
		}
		_Values[n] = endValue;
	}

	/// ctor
	CPSValueBlendSampleFunc() {}

	/// serialization
	void serial(NLMISC::IStream &f) throw(NLMISC::EStream)
	{
		f.serialVersion(1);
		if (f.isReading())
		{
			T t1, t2;
			f.serial(t1, t2);
			setValues(t1, t2);
		}
		else
		{
			f.serial(_Values[0], _Values[n]);
		}
	}

	T getMaxValue(void) const
	{
		return std::max((*this)(0), (*this)(1));
	}
	T getMinValue(void) const
	{
		return std::min((*this)(0), (*this)(1));
	}

protected:
	T  _Values[n + 1];
};




/** This is a Values blender (sampled version, with n sample) class, that operate on value of type T
 *  To use this, just derive a class from a specialization of this template , create a ctor, and declare it to the class registry
 *  in the ctor, you should call _F.setValue to init the functor object
 */

template <typename T, const uint n> class CPSValueBlenderSample : public CPSAttribMakerT<T, CPSValueBlendSampleFunc<T, n> >
{
public:

	/** ctor
	 *  With nbCycles, you can set the pattern frequency. It is usually one. See ps_attrib_maker.h
	 *  For further details
	 */
	CPSValueBlenderSample(float nbCycles) : CPSAttribMakerT<T, CPSValueBlendSampleFunc<T, n> >(nbCycles)
	{
	}
	virtual T getMaxValue(void) const { return this->_F.getMaxValue(); }
	virtual T getMinValue(void) const { return this->_F.getMinValue(); }
};




/**
 * This functor blend between several Value. Intermediate value are sampled with a given number of steps
 * It is used by CPSValueGradient, that you can use to have gradients with your own types
 * \author Nicolas Vizerie
 * \author Nevrax France
 * \date 2001
 */
template <typename T> class CPSValueGradientFunc
{
public:
	/// this produce Values
	#ifdef NL_OS_WINDOWS
		__forceinline
	#endif
	T operator()(TAnimationTime time) const
	{
		#ifdef NL_DEBUG
			nlassert(time >= 0.f && time <= 1.f);
		#endif
		return _Tab[NLMISC::OptFastFloor(time * _NbValues)];
	}

	/// copy the keys values in the specified table
	virtual void getValues(T *tab) const
	{
		nlassert(tab);
		T *pt = tab;
		uint32 src = 0;
		for (uint32 k = 0; k <= (_NbValues / _NbStages); ++k, src = src + _NbStages)
		{
			*pt++ =_Tab[src];
		}
	}

	/// get one value
	virtual T getValue(uint index)	const
	{
		nlassert(index < getNumValues());
		return _Tab[index * _NbStages];
	}




	uint32 getNumValues(void) const { return (_NbValues / _NbStages) + 1; }

	/** set the colors
	 *  \param numValue number of Values, must be >= 2
	 *  \ValueTab a table containing the Values. Value will be blended, so you must only provide keyframe Values
	 *  \param nbStages The result is sampled into a table by linearly interpolating values. This give the number of step between each value
	 *  WARNING : for integer types, some specilization exist that ensure correct interpolation. see below
	 */


	virtual void setValues(const T *ValueTab, uint32 numValues, uint32 nbStages);

	// the same, but value gradient has already been computed, so ValueTab must contains numValues * nbStages + 1 values
	virtual void setValuesUnpacked(const T *ValueTab, uint32 numValues, uint32 nbStages);

	/// get the number of stages between each value
	uint32 getNumStages(void) const { return _NbStages; }

	/// change the number of stages between each value
	void setNumStages(uint32 numStages)
	{
		std::vector<T> v(getNumValues());
		getValues(&v[0]);
		setValues(&v[0], getNumValues(), numStages);
	}

	/// serialization
	virtual void serial(NLMISC::IStream &f) throw(NLMISC::EStream);


	T getMaxValue(void) const
	{
		return _MaxValue;
	}

	T getMinValue(void) const
	{
		return _MinValue;
	}

	/// ctor
	CPSValueGradientFunc() : _NbStages(0), _NbValues(0)
	{
	}
	/// dtor
	virtual ~CPSValueGradientFunc() {}



protected:
	// a table of Values that interpolate the values given
	typename CPSVector<T>::V _Tab;


	// number of interpolated value between each 'key'
	uint32 _NbStages;

	// total number of value in the tab
	uint32 _NbValues;


	// the max value
	T _MaxValue;
	T _MinValue;
};




/** This is a Values gradient class
 *  To use this, just derive a class from a specialization of this template , create a ctor, and declare it to the class registry
 *  in the ctor, you should call _F.setValue to init the functor object
 */

template <typename T> class CPSValueGradient : public CPSAttribMakerT<T, CPSValueGradientFunc<T> >
{
public:

	/** ctor
	 *  With nbCycles, you can set the pattern frequency. It is usually one. See ps_attrib_maker.h
	 *  For further details
	 */
	CPSValueGradient(float nbCycles) : CPSAttribMakerT<T, CPSValueGradientFunc<T> >(nbCycles)
	{
	}
	virtual T getMaxValue(void) const { return this->_F.getMaxValue(); }
	virtual T getMinValue(void) const { return this->_F.getMinValue(); }
};




////////////////////////////
// methods implementations //
////////////////////////////



// tool function used by CPSValueGradientFunc<T>::setValues(
template <typename T>
inline void computeGradient(const T *valueTab, uint32 numValues, uint32 nbStages, typename CPSVector<T>::V &grad, T &minValue, T &maxValue)
{
	minValue = maxValue = valueTab[0];
	float step = 1.0f / float(nbStages);
	float alpha;

	uint nbValues = (numValues - 1) * nbStages;
	grad.resize(nbValues + 1);

	T *dest = &grad[0];
	// copy the tab performing linear interpolation between values given in parameter
	for (uint32 k = 0; k  < (numValues - 1); ++k)
	{
		maxValue = std::max(maxValue, valueTab[k]);
		minValue = std::min(minValue, valueTab[k]);

		alpha = 0;

		for(uint32 l = 0; l < nbStages; ++l)
		{
			// use the right version of the template function PSValueBlend
			// to do the job
			*dest++ = PSValueBlend(valueTab[k], valueTab[k + 1], alpha);
			alpha += step;
		}
	}
	*dest++ = valueTab[numValues - 1];
}

// special optimisation for rgba
void computeGradient(const NLMISC::CRGBA *valueTab, uint32 numValues, uint32 nbStages, CPSVector<CRGBA>::V &grad, NLMISC::CRGBA &minValue, NLMISC::CRGBA &maxValue);


template <typename T>
void CPSValueGradientFunc<T>::setValues(const T *valueTab, uint32 numValues, uint32 nbStages)
{
	nlassert(numValues > 1);
	nlassert(nbStages > 0);

	computeGradient(valueTab, numValues, nbStages, _Tab, _MinValue, _MaxValue);
	//
	_NbStages = nbStages;
	_NbValues = (uint32)_Tab.size() - 1;

}




template <typename T>
void CPSValueGradientFunc<T>::setValuesUnpacked(const T *valueTab, uint32 numValues, uint32 nbStages)
{
	_NbStages = nbStages;
	_MaxValue = _MinValue = valueTab[0];
	_NbValues = (numValues - 1) * nbStages;
	_Tab.resize(_NbValues + 1);
#ifdef NL_COMP_VC14
	std::copy(valueTab, valueTab + _NbValues + 1, stdext::make_checked_array_iterator(&_Tab[0], _Tab.size()));
#else
	std::copy(valueTab, valueTab + _NbValues + 1, &_Tab[0]);
#endif
}




template <typename T>
void CPSValueGradientFunc<T>::serial(NLMISC::IStream &f) throw(NLMISC::EStream)
{
	f.serialVersion(1);
	f.serial(_NbStages);
	if (f.isReading())
	{

		// reload the number of keys

		uint32 numVal;
		f.serial(numVal);
		_NbValues = (numVal - 1) * _NbStages;

		// create the table on the stack for small gradient
		if (NLMISC::CTraits<T>::HasTrivialCtor && NLMISC::CTraits<T>::HasTrivialDtor && numVal < 256)
		{
			uint8 tab[sizeof(T) * 256]; // avoid empty ctor calls
			T *tabT = (T *) tab;
			for (uint32 k = 0; k < numVal; ++k)
			{
				f.serial(tabT[k]);
			}
			setValues(tabT, numVal, _NbStages);
		}
		else
		{
			std::vector<T> tab(numVal);
			for (uint32 k = 0; k < numVal; ++k)
			{
				f.serial(tab[k]);
			}
			setValues(&tab[0], numVal, _NbStages);
		}
	}
	else
	{
		// saves the number of keys
		uint32 numKeyValues = getNumValues();
		f.serial(numKeyValues);


		// save each key
		for (uint32 k = 0; k < numKeyValues; ++k)
		{
			f.serial(_Tab[k * _NbStages]);
		}
	}
}

} // NL3D


#endif // NL_PS_ATTRIB_MAKER_TEMPLATE_H

/* End of ps_attrib_maker_template.h */