// 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/>.

#include "std3d.h"

#include "nel/3d/bone.h"
#include "nel/3d/anim_ctrl.h"
#include "nel/misc/hierarchical_timer.h"


namespace NL3D
{


// ***************************************************************************
// ***************************************************************************
// CBoneBase
// ***************************************************************************
// ***************************************************************************


static	const CVector	UnitScale(1,1,1);


// ***************************************************************************
CBoneBase::CBoneBase() : DefaultPos(CVector(0,0,0)), DefaultRotEuler(CVector(0,0,0)),
	DefaultScale(UnitScale), DefaultPivot(CVector(0,0,0)), SkinScale(UnitScale)
{
	FatherId= -1;
	UnheritScale= true;
	// Default: never disable.
	LodDisableDistance= 0.f;
}


// ***************************************************************************
void			CBoneBase::serial(NLMISC::IStream &f)
{
	/*
	Version 2:
		- SkinScale
	Version 1:
		- LodDisableDistance
	*/
	sint	ver= f.serialVersion(2);

	f.serial(Name);
	f.serial(InvBindPos);
	f.serial(FatherId);
	f.serial(UnheritScale);

	if(ver>=1)
		f.serial(LodDisableDistance);
	else
	{
		// Default: never disable.
		LodDisableDistance= 0.f;
	}

	f.serial(DefaultPos);
	f.serial(DefaultRotEuler);
	f.serial(DefaultRotQuat);
	f.serial(DefaultScale);
	f.serial(DefaultPivot);

	if(ver>=2)
		f.serial(SkinScale);
}


// ***************************************************************************
// ***************************************************************************
// CBone
// ***************************************************************************
// ***************************************************************************


// ***************************************************************************
CBone::CBone(CBoneBase *boneBase)
{
	nlassert(boneBase);
	_BoneBase= boneBase;

	// IAnimatable.
	IAnimatable::resize(AnimValueLast);

	ITransformable::setTransformMode(ITransformable::RotQuat);
	ITransformable::setPos( _BoneBase->DefaultPos.getDefaultValue()  );
	ITransformable::setRotQuat( _BoneBase->DefaultRotQuat.getDefaultValue() );
	ITransformable::setScale( _BoneBase->DefaultScale.getDefaultValue()  );
	ITransformable::setPivot( _BoneBase->DefaultPivot.getDefaultValue()  );

	// By default, the bone is not binded to a channelMixer.
	_PosChannelId= -1;
	_RotEulerChannelId= -1;
	_RotQuatChannelId= -1;
	_ScaleChannelId= -1;
	_PivotChannelId= -1;

	// No animCtrl by default
	_AnimCtrl= NULL;

	// Get default BoneBase SkinScale
	_SkinScale= _BoneBase->SkinScale;
}

// ***************************************************************************
ITrack* CBone::getDefaultTrack (uint valueId)
{
	nlassert(_BoneBase);

	// what value ?
	switch (valueId)
	{
	case PosValue:			return &_BoneBase->DefaultPos;
	case RotEulerValue:		return &_BoneBase->DefaultRotEuler;
	case RotQuatValue:		return &_BoneBase->DefaultRotQuat;
	case ScaleValue:		return &_BoneBase->DefaultScale;
	case PivotValue:		return &_BoneBase->DefaultPivot;
	}

	// No, only ITrnasformable values!
	nlstop;
	// Deriver note: else call BaseClass::getDefaultTrack(valueId);

	return NULL;
}

// ***************************************************************************
void	CBone::registerToChannelMixer(CChannelMixer *chanMixer, const std::string &prefix)
{
	// For CBone, channels are detailled.
	// Bkup each channelId (for disable).
	_PosChannelId= addValue(chanMixer, PosValue, OwnerBit, prefix, true);
	_RotEulerChannelId= addValue(chanMixer, RotEulerValue, OwnerBit, prefix, true);
	_RotQuatChannelId= addValue(chanMixer, RotQuatValue, OwnerBit, prefix, true);
	_ScaleChannelId= addValue(chanMixer, ScaleValue, OwnerBit, prefix, true);
	_PivotChannelId= addValue(chanMixer, PivotValue, OwnerBit, prefix, true);

	// Deriver note: if necessary, call	BaseClass::registerToChannelMixer(chanMixer, prefix);
}

// ***************************************************************************
void	CBone::compute(CBone *parent, const CMatrix &rootMatrix, CSkeletonModel *skeletonForAnimCtrl)
{
	// compute is called typically 800 time per frame.
#ifdef NL_DEBUG
	nlassert(_BoneBase);
#endif

	// get/compute our local matrix
	const CMatrix	&localMatrix= getMatrix();

	// Compute LocalSkeletonMatrix.
	// Root case?
	if(!parent)
	{
		_LocalSkeletonMatrix= localMatrix;
	}
	// Else, son case, take world matrix from parent.
	else
	{
		// UnheritScale case.
		if(_BoneBase->UnheritScale)
		{
			CMatrix		invScaleComp;
			CVector		fatherScale;
			CVector		trans;

			/* Optim note:
				the scale is rarely ==1, so don't optimize case where it may be.
			*/

			// retrieve our translation
			localMatrix.getPos(trans);
			// retrieve scale from our father.
			parent->getScale(fatherScale);
			// inverse this scale.
			fatherScale.x= 1.0f / fatherScale.x;
			fatherScale.y= 1.0f / fatherScale.y;
			fatherScale.z= 1.0f / fatherScale.z;

			// Compute InverseScale compensation:
			// with UnheritScale, formula per bone should be  T*Sf-1*P*R*S*P-1.
			// But getMatrix() return T*P*R*S*P-1.
			// So we must compute T*Sf-1*T-1, in order to get wanted result.
			invScaleComp.setScale(fatherScale);
			// Faster compute of the translation part: just "trans + fatherScale MUL -trans" where MUL is comp mul
			trans.x-= fatherScale.x * trans.x;
			trans.y-= fatherScale.y * trans.y;
			trans.z-= fatherScale.z * trans.z;
			invScaleComp.setPos(trans);


			// And finally, we got ParentWM * T*Sf-1*P*R*S*P-1.
			// Do: _LocalSkeletonMatrix= parent->_LocalSkeletonMatrix * invScaleComp * localMatrix
			static	CMatrix	tmp;
			tmp.setMulMatrixNoProj( parent->_LocalSkeletonMatrix, invScaleComp );
			_LocalSkeletonMatrix.setMulMatrixNoProj( tmp, localMatrix );
		}
		// Normal case.
		else
		{
			// Do: _LocalSkeletonMatrix= parent->_LocalSkeletonMatrix * localMatrix
			_LocalSkeletonMatrix.setMulMatrixNoProj( parent->_LocalSkeletonMatrix, localMatrix );
		}
	}

	// Compute WorldMatrix. Do: _WorldMatrix= rootMatrix * _LocalSkeletonMatrix
	_WorldMatrix.setMulMatrixNoProj( rootMatrix, _LocalSkeletonMatrix );

	// Compute BoneSkinMatrix. Easier of no SkinScale
	if(_SkinScale==UnitScale)
	{
		// Do: _BoneSkinMatrix= _LocalSkeletonMatrix * _BoneBase->InvBindPos
		_BoneSkinMatrix.setMulMatrixNoProj( _LocalSkeletonMatrix, _BoneBase->InvBindPos );
	}
	else
	{
		// Do: _BoneSkinMatrix= _LocalSkeletonMatrix * SkinScale * _BoneBase->InvBindPos
		CMatrix		tmp;
		CMatrix		scaleMat;
		scaleMat.setScale(_SkinScale);
		tmp.setMulMatrixNoProj(_LocalSkeletonMatrix, scaleMat);
		_BoneSkinMatrix.setMulMatrixNoProj( tmp, _BoneBase->InvBindPos );
	}

	// When compute is done, do extra user ctrl?
	if(_AnimCtrl && skeletonForAnimCtrl)
		_AnimCtrl->execute(skeletonForAnimCtrl, this);
}


// ***************************************************************************
void	CBone::interpolateBoneSkinMatrix(const CMatrix &otherMatrix, float interp)
{
	CMatrix		&curMatrix= _BoneSkinMatrix;

	// interpolate rot/scale. Just interpolate basis vectors
	CVector		fatherI= otherMatrix.getI();
	CVector		curI= curMatrix.getI();
	curI= fatherI*(1-interp) + curI*interp;
	CVector		fatherJ= otherMatrix.getJ();
	CVector		curJ= curMatrix.getJ();
	curJ= fatherJ*(1-interp) + curJ*interp;
	CVector		fatherK= otherMatrix.getK();
	CVector		curK= curMatrix.getK();
	curK= fatherK*(1-interp) + curK*interp;
	// replace rotation
	curMatrix.setRot(curI, curJ, curK);

	// interpolate pos
	CVector		fatherPos= otherMatrix.getPos();
	CVector		curPos= curMatrix.getPos();
	curPos= fatherPos*(1-interp) + curPos*interp;
	curMatrix.setPos(curPos);
}


// ***************************************************************************
void	CBone::lodEnableChannels(CChannelMixer *chanMixer, bool enable)
{
	nlassert(chanMixer);

	// Lod Enable channels if they are correclty registered to the channelMixer.
	if( _PosChannelId>=0 )
		chanMixer->lodEnableChannel(_PosChannelId, enable);
	if( _RotEulerChannelId>=0 )
		chanMixer->lodEnableChannel(_RotEulerChannelId, enable);
	if( _RotQuatChannelId>=0 )
		chanMixer->lodEnableChannel(_RotQuatChannelId, enable);
	if( _ScaleChannelId>=0 )
		chanMixer->lodEnableChannel(_ScaleChannelId, enable);
	if( _PivotChannelId>=0 )
		chanMixer->lodEnableChannel(_PivotChannelId, enable);

}

// ***************************************************************************
void	CBone::setSkinScale(CVector &skinScale)
{
	_SkinScale= skinScale;
}


} // NL3D