// 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 "stdafx.h"
#include "export_nel.h"
#include "nel/3d/camera.h"
#include "nel/3d/transform.h"
#include "nel/3d/animation.h"
#include "nel/3d/animated_material.h"
#include "nel/3d/key.h"
#include "nel/3d/track.h"
#include "nel/3d/particle_system_model.h"
#include "nel/3d/skeleton_model.h"
#include "nel/misc/algo.h"
#include <notetrck.h>
#include <functional>

#include "calc_lm.h"
#include "export_appdata.h"

using namespace NLMISC;
using namespace NL3D;

static Class_ID DefNoteTrackClassID(NOTETRACK_CLASS_ID, 0);

#define BOOL_CONTROL_CLASS_ID 0x984b8d27


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

class CExportDesc
{
public:

	// Default cstr;
	CExportDesc ()
	{
		reset ();
	}

	// Reset the desc
	void reset ()
	{
		Specular=false;
	}


	// This value is specular
	bool		Specular;
	StdMat2		*Material;
};


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

// OverSamples fo BIPED animation export.
#define NL3D_BIPED_OVERSAMPLING 30

// Add track in this animation
void CExportNel::addAnimation (CAnimation& animation, INode& node, const char* sBaseName, bool root)
{
	// Get the TM controler
	Control *transform=node.GetTMController();


	// Build information for this nodes and his sons.
	CAnimationBuildCtx	animBuildCtx;
	// Build the biped information.
	buildBipedInformation(animBuildCtx, node);
	animBuildCtx.compileBiped();
	// If it is a biped, over Samples now along the animation, and get Keys values.
	if(animBuildCtx.hasBipedNodes())
	{
		overSampleBipedAnimation(animBuildCtx, NL3D_BIPED_OVERSAMPLING);
	}

	// For Skeleton Spawn Script
	CSSSBuild	ssBuilder;

	// Is it a biped node ?
	if (transform && (transform->ClassID() == BIPBODY_CONTROL_CLASS_ID))
	{
		// Export biped skeleton animation
		addBipedNodeTracks (animation, node, sBaseName, &animBuildCtx, root, ssBuilder);
	}	
	else
	{
		// Add node tracks
		addNodeTracks (animation, node, sBaseName, NULL, root, ssBuilder);

		// Get the object pointer
		Object* obj=node.GetObjectRef();

		// Export the object if it exists
		if (obj)
			addObjTracks (animation, *obj, sBaseName);

		// Export material tracks of this object
		int exportNodeMaterial = CExportNel::getScriptAppData (&node, NEL3D_APPDATA_EXPORT_ANIMATED_MATERIALS, 0);
		{
			if (exportNodeMaterial)
			{			
				Mtl* mtl=node.GetMtl();
				if (mtl)
				{
					// Add material tracks in the animation
					addMtlTracks (animation, *mtl, sBaseName);
				}
			}
		}

		// Add light tracks
		addLightTracks (animation, node, sBaseName);

		// Add particle system tracks
		addParticleSystemTracks(animation, node, sBaseName);

		// Add morph tracks
		addMorphTracks (animation, node, sBaseName);

		// Add bones track
		uint childrenCont=(uint)node.NumberOfChildren();
		for (uint children=0; children<childrenCont; children++)
		{
			INode *child=node.GetChildNode(children);
			addBoneTracks (animation, *child, sBaseName, &animBuildCtx, false, ssBuilder);
		}
	}

	// check for note track export (a string track used to create events)
	int exportNoteTrack = CExportNel::getScriptAppData(&node, NEL3D_APPDATA_EXPORT_NOTE_TRACK, 0);	
	if (exportNoteTrack)
	{
		addNoteTrack(animation, node);		
	}

	// Compile the SkeletonSpawnScript builder
	ssBuilder.compile(animation, sBaseName);
}


// --------------------------------------------------
void CExportNel::addNoteTrack(NL3D::CAnimation& animation, INode& node)
{
	NL3D::CTrackKeyFramerConstString*	st= buildFromNoteTrack(node);
	
	if(st)
		animation.addTrack(std::string("NoteTrack"), st);		
}


// --------------------------------------------------
void CExportNel::addSSSTrack(CSSSBuild	&ssBuilder, INode& node)
{
	CSSSBuild::CBoneScript	bs;
	bs.BoneName= getName (node);

	// Build from note Track (first one)
	NoteTrack *nt = node.GetNoteTrack(0);
    if(nt && (nt->ClassID() == DefNoteTrackClassID))
    {
        DefNoteTrack &dnt = *(DefNoteTrack *)nt;
        int noteCount = dnt.keys.Count();
		float firstDate = 0, lastDate = 0;
		
		// build bs.Track
		bs.Track.reserve(noteCount);
        for(int noteIndex = 0; noteIndex < noteCount; ++noteIndex)
        {
            NoteKey *note = dnt.keys[noteIndex];
			
            if(note)
            {
				CSSSBuild::CKey		ks;
				ks.Value = std::string(note->note);
				ks.Time= CExportNel::convertTime (note->time);
				bs.Track.push_back(ks);
            }
        }
		
		// if some key, add to the builder
		if(!bs.Track.empty())
			ssBuilder.Bones.push_back(bs);
	}
}

// --------------------------------------------------
NL3D::CTrackKeyFramerConstString*		CExportNel::buildFromNoteTrack(INode& node)
{
	// check for the first Note Track		
	NoteTrack *nt = node.GetNoteTrack(0);
	
    if(nt && (nt->ClassID() == DefNoteTrackClassID))
    {
		
		CTrackKeyFramerConstString *st = new CTrackKeyFramerConstString;
		
        DefNoteTrack &dnt = *(DefNoteTrack *)nt;
        int noteCount = dnt.keys.Count();
		float firstDate = 0, lastDate = 0;
		
        for(int noteIndex = 0; noteIndex < noteCount; ++noteIndex)
        {
			
            NoteKey *note = dnt.keys[noteIndex];
			
            if(note)
            {
				CKeyString ks;
				if (noteIndex == 0)
				{
					firstDate = CExportNel::convertTime (note->time);
				}				
				ks.Value = std::string(note->note);
				lastDate = CExportNel::convertTime (note->time);
				st->addKey(ks , lastDate );
				
            }
        }
		st->unlockRange (firstDate, lastDate);

		return st;
	}
	else
		return NULL;
}


// --------------------------------------------------
void CExportNel::addParticleSystemTracks(CAnimation& animation, INode& node, const char* parentName)
{	
	Class_ID  clid = node.GetObjectRef()->ClassID() ;
	/// is this a particle system ?
	if (clid.PartA() != NEL_PARTICLE_SYSTEM_CLASS_ID)
		return ;

	// Export desc
	CExportDesc desc;
	const char *paramName[] = { "PSParam0", "PSParam1", "PSParam2", "PSParam3" } ;
	

	for (uint k = 0 ; k < 4 ; ++k)
	{
		Control *ctrl = getControlerByName(node, paramName[k]) ;
		if (ctrl)
		{
			ITrack *pTrack=buildATrack (animation, *ctrl, typeFloat, node, desc, NULL);
			if (pTrack)
			{
				std::string name=parentName+std::string (NL3D::CParticleSystemModel::getPSParamName((uint) NL3D::CParticleSystemModel::PSParam0 + k));
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}	
	}

	Control *ctrl = getControlerByName(node, "PSTrigger");
	if (ctrl)
	{
		ITrack *pTrack = buildOnOffTrack(*ctrl);
		std::string name=parentName+std::string("PSTrigger");
		if (animation.getTrackByName (name.c_str()))
		{
			delete pTrack;
			pTrack = NULL;
		}
		else
		{
			animation.addTrack(name, pTrack);
		}
	}
}


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

void CExportNel::addNodeTracks (CAnimation& animation, INode& node, const char* parentName,
								CAnimationBuildCtx	*animBuildCtx, bool root, CSSSBuild &ssBuilder, bool bodyBiped)
{
	// Tmp track*
	ITrack *pTrack;

	// Tmp name
	std::string name;

	// Export desc
	CExportDesc desc;

	// Export scale
	desc.reset();

	// Get the transformation controler
	Control *transform=node.GetTMController();

	// It exists ?
	if (transform)
	{
		// Get the Scale controler
		Control *c=transform->GetScaleController ();
		if (c)
		{
			// Build the track
			pTrack=buildATrack (animation, *c, typeScale, node, desc, animBuildCtx, bodyBiped);
			if (pTrack)
			{
				name=parentName+std::string (ITransformable::getScaleValueName());
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}

		// Export rotation
		desc.reset();

		// Get the Rotation controler
		c=transform->GetRotationController ();
		if (c)
		{
			pTrack=buildATrack (animation, *c, typeRotation, node, desc, animBuildCtx, bodyBiped);
			if (pTrack)
			{
				// Choose the good name for this track
				name=parentName+std::string (ITransformable::getRotQuatValueName());
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}

		// Export position
		desc.reset();

		// Get the Position controler
		c=transform->GetPositionController ();
		if (c)
		{
			pTrack=buildATrack (animation, *c, typePos, node, desc, animBuildCtx, bodyBiped);
			if (pTrack)
			{
				// Choose the good name for this track
				name=parentName+std::string (ITransformable::getPosValueName());
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}
		else
		{
			// try to find a biped controller for position
			pTrack=buildATrack (animation, *transform, typePos, node, desc, animBuildCtx, bodyBiped);
			if (pTrack)
			{
				// Choose the good name for this track
				name=parentName+std::string (ITransformable::getPosValueName());
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}

		// Export roll for camera
		desc.reset();

		if (isCamera (node, 0))
		{
			// Get the Roll controler
			c=transform->GetRollController ();
			if (c)
			{
				pTrack=buildATrack (animation, *c, typeFloat, node, desc, animBuildCtx, bodyBiped);
				if (pTrack)
				{
					name=parentName+std::string (CCamera::getRollValueName());
					if (animation.getTrackByName (name.c_str()))
					{
						delete pTrack;
						pTrack = NULL;
					}
					else
					{
						animation.addTrack (name.c_str(), pTrack);
					}
				}
			}

			// Export target position for camera
			desc.reset();

			// Get the target controler
			INode *target = node.GetTarget ();
			if (target)
			{
				// Get the transformation controler
				Control *targetTransform = target->GetTMController();

				// Get the Position controler
				Control *targetC = targetTransform->GetPositionController ();
				if (targetC)
				{
					pTrack=buildATrack (animation, *targetC, typePos, *target, desc, animBuildCtx, bodyBiped);
					if (pTrack)
					{
						// Choose the good name for this track
						name=parentName+std::string (CCamera::getTargetValueName());
						if (animation.getTrackByName (name.c_str()))
						{
							delete pTrack;
							pTrack = NULL;
						}
						else
						{
							animation.addTrack (name.c_str(), pTrack);
						}
					}
				}
			}
		}
	}

	// check for SkeletonSpawnScript track export
	int exportSSS = CExportNel::getScriptAppData(&node, NEL3D_APPDATA_EXPORT_SSS_TRACK, 0);	
	if(exportSSS)
	{
		addSSSTrack(ssBuilder, node);
	}
}

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

void CExportNel::addBipedNodeTracks (CAnimation& animation, INode& node, const char* parentName, CAnimationBuildCtx	*animBuildCtx, bool root, CSSSBuild &ssBuilder)
{
	// Get the matrix controler
	Control *transform=node.GetTMController();
	nlassert (transform);

	// Biped node
	if ((transform->ClassID() == BIPSLAVE_CONTROL_CLASS_ID) ||
		(transform->ClassID() == BIPBODY_CONTROL_CLASS_ID))
	{
		// Body biped ?
		bool bodyBiped = ((transform->ClassID() == BIPBODY_CONTROL_CLASS_ID) != 0);

		// Create a track name
		std::string name;
		
		// Choose the good name for this track
		if (!root)
			name=parentName + getName (node) + ".";
		else
			name=parentName;

		// Export keyframes
		addNodeTracks (animation, node, name.c_str(), animBuildCtx, root, ssBuilder, bodyBiped);

		// Add child tracks
		uint childrenCont=(uint)node.NumberOfChildren();
		for (uint children=0; children<childrenCont; children++)
		{
			INode *child=node.GetChildNode(children);
			addBipedNodeTracks (animation, *child, parentName, animBuildCtx, false, ssBuilder);
		}
	}
	else
	{
		// Add normal tracks
		addBoneTracks (animation, node, parentName, animBuildCtx, root, ssBuilder);
	}
}

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

void CExportNel::addBoneTracks (NL3D::CAnimation& animation, INode& node, const char* parentName, CAnimationBuildCtx *animBuildCtx, bool root, CSSSBuild &ssBuilder)
{
	// Create a track name
	std::string name=parentName + getName (node) + ".";

	// Get the TM controler
	Control *transform=node.GetTMController();

	// Is it a biped node ?
	if (transform && (transform->ClassID() == BIPBODY_CONTROL_CLASS_ID))
	{
		// Export biped skeleton animation
		addBipedNodeTracks (animation, node, parentName, animBuildCtx, root, ssBuilder);
	}
	else
	{
		// Go for normal export!
		addNodeTracks (animation, node, name.c_str(), NULL, root, ssBuilder);
	}

	// Recursive call
	uint childrenCont=(uint)node.NumberOfChildren();
	for (uint children=0; children<childrenCont; children++)
	{
		INode *child=node.GetChildNode(children);
		addBoneTracks (animation, *child, parentName, animBuildCtx, false, ssBuilder);
	}
}

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

void CExportNel::addLightTracks (NL3D::CAnimation& animation, INode& node, const char* parentName)
{
	CExportDesc desc;

	ObjectState os = node.EvalWorldState(0);
    Object *obj = os.obj;

	// Check if there is an object
	if (!obj)
		return;

	// Get a GenLight from the node
	if( ! (obj->SuperClassID()==LIGHT_CLASS_ID) )
		return;

	// Create a track name
	std::string name = CExportNel::getAnimatedLight (&node);
	name = "LightmapController." + name;

	int bAnimated = CExportNel::getScriptAppData (&node, NEL3D_APPDATA_LM_ANIMATED, 0);
	if( bAnimated )
	{
		Control *c = getControlerByName(node,"Color");
		if( c )
		{
			ITrack *pTrack=buildATrack (animation, *c, typeColor, node, desc, NULL);
			if (pTrack)
			{
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}
	}
}

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

void CExportNel::addMorphTracks (NL3D::CAnimation& animation, INode& node, const char* parentName)
{
	CExportDesc desc;
	Modifier *pMorphMod = getModifier (&node, MAX_MORPHER_CLASS_ID);

	if (pMorphMod == NULL)
		return;

	uint32 i;

	for (i = 0; i < 100; ++i)
	{
		INode *pNode = (INode*)pMorphMod->GetReference (101+i);
		if (pNode == NULL)
			continue;
		std::string name = parentName;
		name += tStrToUtf8(pNode->GetName());
		name += "MorphFactor";
		
		IParamBlock *pb = (IParamBlock*)(pMorphMod->SubAnim (i+1));
		Control *c = pb->GetController (0);
		
		if (c != NULL)
		{
			ITrack *pTrack = buildATrack (animation, *c, typeFloat, node, desc, NULL);
			if (pTrack)
			{
				if (animation.getTrackByName (name.c_str()))
				{
					delete pTrack;
					pTrack = NULL;
				}
				else
				{
					animation.addTrack (name.c_str(), pTrack);
				}
			}
		}
	}
}


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

void CExportNel::addObjTracks (CAnimation& animation, Object& obj, const char* parentName)
{
	// Export fov for camera
	CExportDesc desc;
	desc.reset();

	// Get the FOV controler
	Control *c=getControlerByName (obj, "FOV");
	if (c)
	{
		ITrack *pTrack=buildATrack (animation, *c, typeFloat, obj, desc, NULL);
		if (pTrack)
		{
			std::string name=parentName+std::string (CCamera::getFovValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}
}

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

void CExportNel::addMtlTracks (CAnimation& animation, Mtl& mtl, const char* parentName)
{	

	// Material name
	std::string mtlName=std::string(parentName)+getName (mtl)+".";

	// Tmp track*
	ITrack *pTrack;

	// Tmp name
	std::string name;

	// Export desc
	CExportDesc desc;

	// *** Export ambient
	desc.reset();

	// Get a controller pointer
	Control* c=getControlerByName (mtl, "ambient");
	if (c)
	{
		// Build a track for this controller
		pTrack=buildATrack (animation, *c, typeColor, mtl, desc, NULL);
		if (pTrack)
		{
			// Add it in the animation
			name=mtlName+std::string (CAnimatedMaterial::getAmbientValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}

	// *** Export diffuse
	desc.reset();

	// Get a controller pointer
	c=getControlerByName (mtl, "diffuse");
	if (c)
	{
		// Build a track for this controller
		pTrack=buildATrack (animation, *c, typeColor, mtl, desc, NULL);
		if (pTrack)
		{
			// Add it in the animation
			name=mtlName+std::string (CAnimatedMaterial::getDiffuseValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}

	// *** Export specular
	desc.reset();
	desc.Specular=true;
	desc.Material=(StdMat2*)&mtl;

	// Get a controller pointer
	c=getControlerByName (mtl, "specular");
	if (c)
	{
		// Build a track for this controller
		pTrack=buildATrack (animation, *c, typeColor, mtl, desc, NULL);
		if (pTrack)
		{
			// Add it in the animation
			name=mtlName+std::string (CAnimatedMaterial::getSpecularValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}

	// *** Export emissive
	desc.reset();

	// Get a controller pointer
	c=getControlerByName (mtl, "selfIllumColor");
	if (c)
	{
		// Build a track for this controller
		pTrack=buildATrack (animation, *c, typeColor, mtl, desc, NULL);
		if (pTrack)
		{
			// Add it in the animation
			name=mtlName+std::string (CAnimatedMaterial::getEmissiveValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}
     
	// *** Export opacity
	desc.reset();

	// Get a controller pointer
	c=getControlerByName (mtl, "opacity");
	if (c)
	{
		// Build a track for this controller
		pTrack=buildATrack (animation, *c, typeFloat, mtl, desc, NULL);
		if (pTrack)
		{
			// Add it in the animation
			name=mtlName+std::string (CAnimatedMaterial::getOpacityValueName());
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}
	

	// Export sub materials tracks
	int s;
	int subMtl=mtl.NumSubMtls();
	for (s=0; s<subMtl; s++)
		addMtlTracks (animation, *mtl.GetSubMtl(s), parentName);

	// Export sub texmaps tracks
	/*subMtl=mtl.NumSubTexmaps();
	for (s=0; s<subMtl; s++)
		addTexTracks (animation, *mtl.GetSubTexmap(s), parentName);*/

	// *** export textures matrix animation if enabled

	/// test wether texture matrix animation should be exported
	int bExportTexMatAnim;
	CExportNel::getValueByNameUsingParamBlock2 (mtl, "bExportTextureMatrix", (ParamType2)TYPE_BOOL, &bExportTexMatAnim, 0);

	if (bExportTexMatAnim != 0)
	{
		for (uint i=0; i<IDRV_MAT_MAXTEXTURES; i++)
		{			
			// Get the enable flag name
			char enableSlotName[100];
			smprintf (enableSlotName, 100, "bEnableSlot_%d", i+1);

			// Get the enable flag 
			int bEnableSlot = 0;
			CExportNel::getValueByNameUsingParamBlock2 (mtl, enableSlotName, (ParamType2)TYPE_BOOL, &bEnableSlot, 0);
			if (bEnableSlot)
			{
				// Get the texture arg name
				char textureName[100];
				smprintf (textureName, 100, "tTexture_%d", i+1);

				// Get the texture pointer
				Texmap *pTexmap = NULL;
				CExportNel::getValueByNameUsingParamBlock2 (mtl, textureName, (ParamType2)TYPE_TEXMAP, &pTexmap, 0);
				if (pTexmap)
				{
					addTexTracks(animation, *pTexmap, i, mtlName.c_str());
				}
			}
		}
	}
}

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

void CExportNel::addTexTracks (CAnimation& animation, Texmap& tex, uint stage, const char* parentName)
{
	// Texmap name
	

	// Tmp track*
	ITrack *pTrack;

	std::string name;

	CExportDesc desc;


	/// export the u translation
	// Get a controller pointer
	Control* c = getControlerByName (tex, "U Offset");
	if (c)
	{
		desc.reset();
		pTrack=buildATrack (animation, *c, typeFloat, tex, desc, NULL);
		if (pTrack)
		{
			name = parentName + std::string (CAnimatedMaterial::getTexMatUTransName(stage));
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}


	/// export the v translation
	// Get a controller pointer
                                    	c=getControlerByName (tex, "V Offset");
	if (c)
	{
		desc.reset();
		pTrack=buildATrack (animation, *c, typeFloat, tex, desc, NULL);
		if (pTrack)
		{
			name = parentName + std::string (CAnimatedMaterial::getTexMatVTransName(stage));
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}


	/// export the u scale
	// Get a controller pointer
	c = getControlerByName (tex, "U Tiling");
	if (c)
	{
		desc.reset();
		pTrack=buildATrack (animation, *c, typeFloat, tex, desc, NULL);
		if (pTrack)
		{
			name = parentName + std::string (CAnimatedMaterial::getTexMatUScaleName(stage));
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}


	/// export the v scale
	// Get a controller pointer
	c=getControlerByName (tex, "V Tiling");
	if (c)
	{
		desc.reset();
		pTrack=buildATrack (animation, *c, typeFloat, tex, desc, NULL);
		if (pTrack)
		{
			name = parentName + std::string (CAnimatedMaterial::getTexMatVScaleName(stage));
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}


	/// export the w rotation
	// Get a controller pointer
	c=getControlerByName (tex, "W Angle");
	if (c)
	{
		desc.reset();
		pTrack=buildATrack (animation, *c, typeFloat, tex, desc, NULL);
		if (pTrack)
		{
			name = parentName + std::string (CAnimatedMaterial::getTexMatWRotName(stage));
			if (animation.getTrackByName (name.c_str()))
			{
				delete pTrack;
				pTrack = NULL;
			}
			else
			{
				animation.addTrack (name.c_str(), pTrack);
			}
		}
	}
}



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

// Build nel keys
void CExportNel::buildNelKey (CKeyFloat& nelKey, ILinFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=maxKey.val;
}

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

void CExportNel::buildNelKey (CKeyInt& nelKey, ILinFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=(sint32)maxKey.val;
}

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

void CExportNel::buildNelKey (CKeyBool& nelKey, ILinFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=fabs(maxKey.val)<=FLOAT_EPSILON;
}

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

void CExportNel::buildNelKey (NL3D::CKeyVector& nelKey, ILinPoint3Key& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.x=maxKey.val.x;
	nelKey.Value.y=maxKey.val.y;
	nelKey.Value.z=maxKey.val.z;

	// Specular
	if (desc.Specular)
	{
		float shininess=desc.Material->GetShinStr(maxKey.time);
		nelKey.Value.x*=shininess;
		nelKey.Value.y*=shininess;
		nelKey.Value.z*=shininess;
	}
}

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

void CExportNel::buildNelKey (NL3D::CKeyRGBA& nelKey, ILinPoint3Key& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.R=(uint8)maxKey.val.x;
	nelKey.Value.G=(uint8)maxKey.val.y;
	nelKey.Value.B=(uint8)maxKey.val.z;
	nelKey.Value.A=255;

	// Specular
	if (desc.Specular)
	{
		float shininess=desc.Material->GetShinStr(maxKey.time);
		clamp (shininess, 0.f, 1.f);
		nelKey.Value.modulateFromui (nelKey.Value, (uint8)(shininess*255.f));
	}
}

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

void CExportNel::buildNelKey (NL3D::CKeyQuat& nelKey, ILinRotKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.w=-maxKey.val.w;
	nelKey.Value.x=maxKey.val.x;
	nelKey.Value.y=maxKey.val.y;
	nelKey.Value.z=maxKey.val.z;
}

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

void CExportNel::buildNelKey (NL3D::CKeyVector& nelKey, ILinScaleKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	// Make a scale matrix
	Matrix3 srtm, stm, mat;
	maxKey.val.q.MakeMatrix(srtm);
	stm = ScaleMatrix(maxKey.val.s);
	mat = Inverse(srtm) * stm * srtm;

	// Get a NeL matrix
	CMatrix scaleMatrix;
	convertMatrix (scaleMatrix, mat);
	
	// Export it
	nelKey.Value.x=scaleMatrix.getI().x;
	nelKey.Value.y=scaleMatrix.getJ().y;
	nelKey.Value.z=scaleMatrix.getK().z;
}

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

void CExportNel::buildNelKey (NL3D::CKeyBezierFloat& nelKey, IBezFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=maxKey.val;
	nelKey.InTan=maxKey.intan;
	nelKey.OutTan=maxKey.outtan;
	
	// Step mode ?
	if (GetOutTanType(maxKey.flags)==BEZKEY_STEP)
		nelKey.Step=true;
	else
		nelKey.Step=false;
}

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

void CExportNel::buildNelKey (NL3D::CKeyBool& nelKey, IBezFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=fabs(maxKey.val)<=FLOAT_EPSILON;
}

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

void CExportNel::buildNelKey (NL3D::CKeyBezierVector& nelKey, IBezPoint3Key& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.x=maxKey.val.x;
	nelKey.Value.y=maxKey.val.y;
	nelKey.Value.z=maxKey.val.z;
	nelKey.InTan.x=ticksPerSecond*maxKey.intan.x;
	nelKey.InTan.y=ticksPerSecond*maxKey.intan.y;
	nelKey.InTan.z=ticksPerSecond*maxKey.intan.z;
	nelKey.OutTan.x=ticksPerSecond*maxKey.outtan.x;
	nelKey.OutTan.y=ticksPerSecond*maxKey.outtan.y;
	nelKey.OutTan.z=ticksPerSecond*maxKey.outtan.z;
	
	// Step mode ?
	if (GetOutTanType(maxKey.flags)==BEZKEY_STEP)
		nelKey.Step=true;
	else
		nelKey.Step=false;

	// Specular
	if (desc.Specular)
	{
		float shininess=desc.Material->GetShinStr(maxKey.time);
		nelKey.Value.x*=shininess;
		nelKey.Value.y*=shininess;
		nelKey.Value.z*=shininess;
	}
}

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

void CExportNel::buildNelKey (NL3D::CKeyBezierQuat& nelKey, IBezQuatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.w=-maxKey.val.w;
	nelKey.Value.x=maxKey.val.x;
	nelKey.Value.y=maxKey.val.y;
	nelKey.Value.z=maxKey.val.z;
}

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

void CExportNel::buildNelKey (NL3D::CKeyBezierVector& nelKey, IBezScaleKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	// Make a scale matrix
	Matrix3 srtm, stm, mat;
	maxKey.val.q.MakeMatrix(srtm);
	stm = ScaleMatrix(maxKey.val.s);
	mat = Inverse(srtm) * stm * srtm;

	// Get a NeL matrix
	CMatrix scaleMatrix;
	convertMatrix (scaleMatrix, mat);

	// Export it
	nelKey.Value.x=scaleMatrix.getI().x;
	nelKey.Value.y=scaleMatrix.getJ().y;
	nelKey.Value.z=scaleMatrix.getK().z;
	nelKey.InTan.x=maxKey.intan.x;
	nelKey.InTan.y=maxKey.intan.y;
	nelKey.InTan.z=maxKey.intan.z;
	nelKey.OutTan.x=maxKey.outtan.x;
	nelKey.OutTan.y=maxKey.outtan.y;
	nelKey.OutTan.z=maxKey.outtan.z;
	
	// Step mode ?
	if (GetOutTanType(maxKey.flags)==BEZKEY_STEP)
		nelKey.Step=true;
	else
		nelKey.Step=false;
}

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

void CExportNel::buildNelKey (NL3D::CKeyTCBFloat& nelKey, ITCBFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=maxKey.val;
	nelKey.Tension=maxKey.tens;
	nelKey.Continuity=maxKey.cont;
	nelKey.Bias=maxKey.bias;
	nelKey.EaseTo=maxKey.easeIn;
	nelKey.EaseFrom=maxKey.easeOut;
}

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

void CExportNel::buildNelKey (NL3D::CKeyBool& nelKey, ITCBFloatKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value=fabs(maxKey.val)<=FLOAT_EPSILON;
}

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

void CExportNel::buildNelKey (NL3D::CKeyTCBVector& nelKey, ITCBPoint3Key& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.x=maxKey.val.x;
	nelKey.Value.y=maxKey.val.y;
	nelKey.Value.z=maxKey.val.z;
	nelKey.Tension=maxKey.tens;
	nelKey.Continuity=maxKey.cont;
	nelKey.Bias=maxKey.bias;
	nelKey.EaseTo=maxKey.easeIn;
	nelKey.EaseFrom=maxKey.easeOut;

	// Specular
	if (desc.Specular)
	{
		float shininess=desc.Material->GetShinStr(maxKey.time);
		nelKey.Value.x*=shininess;
		nelKey.Value.y*=shininess;
		nelKey.Value.z*=shininess;
	}
}

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

void CExportNel::buildNelKey (NL3D::CKeyTCBQuat& nelKey, ITCBRotKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	nelKey.Value.Angle=-maxKey.val.angle;
	nelKey.Value.Axis.x=maxKey.val.axis.x;
	nelKey.Value.Axis.y=maxKey.val.axis.y;
	nelKey.Value.Axis.z=maxKey.val.axis.z;
	nelKey.Tension=maxKey.tens;
	nelKey.Continuity=maxKey.cont;
	nelKey.Bias=maxKey.bias;
	nelKey.EaseTo=maxKey.easeIn;
	nelKey.EaseFrom=maxKey.easeOut;
}

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

void CExportNel::buildNelKey (NL3D::CKeyTCBVector& nelKey, ITCBScaleKey& maxKey, float ticksPerSecond, const CExportDesc& desc, Control& c)
{
	// Make a scale matrix
	Matrix3 srtm, stm, mat;
	maxKey.val.q.MakeMatrix(srtm);
	stm = ScaleMatrix(maxKey.val.s);
	mat = Inverse(srtm) * stm * srtm;

	// Get a NeL matrix
	CMatrix scaleMatrix;
	convertMatrix (scaleMatrix, mat);
	
	// Export it
	nelKey.Value.x=scaleMatrix.getI().x;
	nelKey.Value.y=scaleMatrix.getJ().y;
	nelKey.Value.z=scaleMatrix.getK().z;
	nelKey.Tension=maxKey.tens;
	nelKey.Continuity=maxKey.cont;
	nelKey.Bias=maxKey.bias;
	nelKey.EaseTo=maxKey.easeIn;
	nelKey.EaseFrom=maxKey.easeOut;
}

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


// Build a Nel bool track from a On/Off max Controller (doesn't work with buildATRack, which require a keyframer interface
// , which isn't provided by an on / off controller)
 NL3D::CTrackKeyFramerConstBool*			CExportNel::buildOnOffTrack(Control& c)
 {
	// make sure this is the controler we want
//	nlassert(c.ClassID() == Class_ID(BOOL_CONTROL_CLASS_ID, 0));	
	float value = 0.f;
	
	CTrackKeyFramerConstBool *track = new CTrackKeyFramerConstBool;

	// ** Get the range of the controler
	Interval range=c.GetTimeRange (TIMERANGE_ALL);

	// ** Get the out of range type
	int oRT=c.GetORT (ORT_AFTER);

	// Set the range
	if ((!(FOREVER==range))&&(!(NEVER==range)))
		track->unlockRange (CExportNel::convertTime (range.Start()), CExportNel::convertTime (range.End()));

	// Set the out of range type
	switch (oRT)
	{
	case ORT_LOOP:
		track->setLoopMode(true);
		break;
	case ORT_CONSTANT:
	case ORT_CYCLE:
	default:
		track->setLoopMode(false);
		break;
	}

	// Enum the keys
	int numKeys = c.NumKeys();
	float firstKey;
	float lastKey;
	for (int i=0; i<numKeys; i++) 
	{		
		// First key ?
		if (i==0)
			firstKey = convertTime (c.GetKeyTime(i));

		// Last key ?
		lastKey = convertTime (c.GetKeyTime(i));

		// Allocate the key
		CKey<bool> nelKey;		
		c.GetValue(c.GetKeyTime(i), &value, range, CTRL_ABSOLUTE);
		nelKey.Value = value > 0.f;
		track->addKey(nelKey, convertTime (c.GetKeyTime(i)));		
	}

	// Invalid interval ? Take the interval of the keyfarmer
	if ((FOREVER==range)||(NEVER==range))
		track->unlockRange (firstKey, lastKey);

	
	return track;
 }



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

// Create a keyframer
template<class TTracker, class TKey, class TMaxKey>
ITrack* createKeyFramer (IKeyControl *ikeys, TTracker*, TKey*, TMaxKey*, float ticksPerSecond, const Interval& range, int oRT, 
						 const CExportDesc& desc, Control &c)
{
	// Allocate the tracker
	TTracker *pLinTrack=new TTracker;

	// Set the range
	if ((!(FOREVER==range))&&(!(NEVER==range)))
		pLinTrack->unlockRange (CExportNel::convertTime (range.Start()), CExportNel::convertTime (range.End()));

	// Set the out of range type
	switch (oRT)
	{
	case ORT_LOOP:
		pLinTrack->setLoopMode(true);
		break;
	case ORT_CONSTANT:
	case ORT_CYCLE:
	default:
		pLinTrack->setLoopMode(false);
		break;
	}

	// Enum the keys
	TMaxKey key;
	int numKeys = ikeys->GetNumKeys();
	float firstKey;
	float lastKey;
	for (int i=0; i<numKeys; i++) 
	{
		// Get the key
		ikeys->GetKey(i, &key);

		// First key ?
		if (i==0)
			firstKey=CExportNel::convertTime (key.time);

		// Last key ?
		lastKey=CExportNel::convertTime (key.time);

		// Allocate the key
		TKey nelKey;

		// Build the key
		CExportNel::buildNelKey (nelKey, key, ticksPerSecond, desc, c);

		// Add the good key
		pLinTrack->addKey (nelKey, CExportNel::convertTime (key.time));
	}

	// Invalid interval ? Take the inteval of the keyfarmer
	if ((FOREVER==range)||(NEVER==range))
		pLinTrack->unlockRange (firstKey, lastKey);


	// Return the keyframer
	return pLinTrack;
}

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

class CDoomyKey : public IKey
{
	char toto[2048];
};

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

// Create the matrix tracks
void CExportNel::createBipedKeyFramer (ITrack *&nelRot, ITrack *&nelPos, bool isRot, bool isPos, float ticksPerSecond, 
									   const Interval& range, int oRT, const CExportDesc& desc, INode& node, 
									   CAnimationBuildCtx	*animBuildCtx)
{
	/*
		Yoyo:
		The New version of this exporter over sample All frame along the animation.
		A CTrackSampleQuat/CTrackSampleVector will be used late in process (at compression time).
	*/

	nelRot=NULL;
	nelPos=NULL;

	// Type of the track
	typedef CTrackKeyFramerLinearVector	TMPos;
	typedef CTrackKeyFramerLinearQuat	TMRot;
	typedef CKeyVector					TMPosKey;
	typedef CKeyQuat					TMRotKey;

	// Find the Biped node info in the build ctx.
	nlassert(animBuildCtx);
	CAnimationBuildCtx::CBipedNode	*bipedNodeInfo= animBuildCtx->getBipedNodeInfo(&node);
	nlassert(bipedNodeInfo);

	// Number of keys
	uint numKeys = bipedNodeInfo->Keys.size();

	// No null keys ?
	if (numKeys!=0)
	{
		// Allocate the keyframer
		if(isRot)			
			nelRot=new TMRot;
		if (isPos)
			nelPos=new TMPos;

		// Set the range
		if ((!(FOREVER==range))&&(!(NEVER==range)))
		{
			if (isRot)
				((TMRot*)nelRot)->unlockRange (CExportNel::convertTime (range.Start()), CExportNel::convertTime (range.End()));
			if (isPos)
				((TMPos*)nelPos)->unlockRange (CExportNel::convertTime (range.Start()), CExportNel::convertTime (range.End()));
		}

		// Set the out of range type
		switch (oRT)
		{
		case ORT_LOOP:
			if (isRot)
				((TMRot*)nelRot)->setLoopMode(true);
			if (isPos)
				((TMPos*)nelPos)->setLoopMode(true);
			break;
		case ORT_CONSTANT:
		case ORT_CYCLE:
		default:
			if (isRot)
				((TMRot*)nelRot)->setLoopMode(false);
			if (isPos)
				((TMPos*)nelPos)->setLoopMode(false);
			break;
		}

		// Enum the keys
		float firstKey;
		float lastKey;
		CQuat previous;
		for(uint key=0; key<numKeys; key++)
		{
			CAnimationBuildCtx::CBipedKey	&bipedKey= bipedNodeInfo->Keys[key];

			// First key ?
			if (key==0)
				firstKey=convertTime (bipedKey.Time);

			// Last key ?
			lastKey=convertTime (bipedKey.Time);

			// Allocate the key
			TMRotKey		theRot;
			TMPosKey		thePos;
	
			// Get Pos/Rot/Scale from overSampled values in the animBuildCtx
			CQuat tmpQuat= bipedKey.Quat;
			thePos.Value= bipedKey.Pos;
			tmpQuat.normalize();

			// Make closest with previous
			if (key>0)
			{
				tmpQuat.makeClosest (previous);
			}

			// Set previous
			previous=tmpQuat;

			// Copy to key
			theRot.Value= tmpQuat;

			// Add the good keys
			if (isRot)
				((TMRot*)nelRot)->addKey (theRot, convertTime (bipedKey.Time));
			if (isPos)
				((TMPos*)nelPos)->addKey (thePos, convertTime (bipedKey.Time));
		}

		// Invalid interval ? Take the inteval of the keyfarmer
		if ((FOREVER==range)||(NEVER==range))
		{
			if (isRot)
				((TMRot*)nelRot)->unlockRange (firstKey, lastKey);
			if (isPos)
				((TMPos*)nelPos)->unlockRange (firstKey, lastKey);
		}
	}
}

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

NL3D::TAnimationTime	CExportNel::convertTime (TimeValue time)
{
	return (float)time/((float)GetTicksPerFrame()*(float)GetFrameRate());
}

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

// Build a NeL track with a 3dsmax controler.
ITrack* CExportNel::buildATrack (CAnimation& animation, Control& c, TNelValueType type, Animatable& node, const CExportDesc& desc,
								 CAnimationBuildCtx	*animBuildCtx, bool bodyBiped)
{
	// What kind of controler?

	/*
	 * Those controlers are supported:
	 *
	 * LININTERP_FLOAT_CLASS_ID
	 * LININTERP_POSITION_CLASS_ID
	 * LININTERP_ROTATION_CLASS_ID
	 * LININTERP_SCALE_CLASS_ID
	 * HYBRIDINTERP_FLOAT_CLASS_ID
	 * HYBRIDINTERP_POSITION_CLASS_ID
	 * HYBRIDINTERP_ROTATION_CLASS_ID
	 * HYBRIDINTERP_POINT3_CLASS_ID
	 * HYBRIDINTERP_SCALE_CLASS_ID
	 * TCBINTERP_FLOAT_CLASS_ID
	 * TCBINTERP_POSITION_CLASS_ID
	 * TCBINTERP_ROTATION_CLASS_ID
	 * TCBINTERP_POINT3_CLASS_ID
	 * TCBINTERP_SCALE_CLASS_ID
	 * BIPSLAVE_CONTROL_CLASS_ID
	 * BIPBODY_CONTROL_CLASS_ID
	 *
	 * Thoses controlers are not supported:
	 *
	 * LOOKAT_CONTROL_CLASS_ID
	 * PATH_CONTROL_CLASS_ID
	 * EXPR_POS_CONTROL_CLASS_ID
	 * EXPR_P3_CONTROL_CLASS_ID
	 * EXPR_FLOAT_CONTROL_CLASS_ID
	 * EXPR_SCALE_CONTROL_CLASS_ID
	 * EXPR_ROT_CONTROL_CLASS_ID
	 * SURF_CONTROL_CLASSID
	 * LINKCTRL_CLASSID
	 *
	 * May be supported in futur:
	 *
	 * EULER_CONTROL_CLASS_ID
	 * FLOATNOISE_CONTROL_CLASS_ID
	 * POSITIONNOISE_CONTROL_CLASS_ID
	 * POINT3NOISE_CONTROL_CLASS_ID
	 * ROTATIONNOISE_CONTROL_CLASS_ID
	 * SCALENOISE_CONTROL_CLASS_ID
	 * HYBRIDINTERP_COLOR_CLASS_ID
	 * FOOTPRINT_CLASS_ID
	 */

	ITrack* pTrack=NULL;

	// ** Get the 3dsmax key control.
	IKeyControl *ikeys=GetKeyControlInterface ((&c));

	// ** Get number of ticks per second
	float ticksPerSecond=(float)TIME_TICKSPERSEC;

	// ** Get the range of the controler
	Interval range=c.GetTimeRange (TIMERANGE_ALL);

	// ** Get the out of range type
	int oRT=c.GetORT (ORT_AFTER);

	// ** Check all keyframer if it is one.
	if (ikeys)
	{
		if (ikeys->GetNumKeys()>0)
		{
			// ** Linear nel keyframe

			if (c.ClassID()==Class_ID(LININTERP_FLOAT_CLASS_ID,0))
			{
				// For float
				if (type==typeFloat)
					pTrack=createKeyFramer<CTrackKeyFramerLinearFloat, CKeyFloat, ILinFloatKey> (ikeys,
						(CTrackKeyFramerLinearFloat*)NULL, (CKeyFloat*)NULL, (ILinFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For int
				if (type==typeInt)
					pTrack=createKeyFramer<CTrackKeyFramerLinearInt, CKeyInt, ILinFloatKey> (ikeys,
						(CTrackKeyFramerLinearInt*)NULL, (CKeyInt*)NULL, (ILinFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For bool
				if (type==typeBoolean)
					pTrack=createKeyFramer<CTrackKeyFramerConstBool, CKeyBool, ILinFloatKey> (ikeys,
						(CTrackKeyFramerConstBool*)NULL, (CKeyBool*)NULL, (ILinFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(LININTERP_POSITION_CLASS_ID,0))
			{
				// For vector
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerLinearVector, CKeyVector, ILinPoint3Key> (ikeys,
						(CTrackKeyFramerLinearVector*)NULL, (CKeyVector*)NULL, (ILinPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For color
				if (type==typeColor)
					pTrack=createKeyFramer<CTrackKeyFramerLinearRGBA, CKeyRGBA, ILinPoint3Key> (ikeys,
						(CTrackKeyFramerLinearRGBA*)NULL, (CKeyRGBA*)NULL, (ILinPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(LININTERP_ROTATION_CLASS_ID,0))
			{
				// For quaternion
				if (type==typeRotation)
					pTrack=createKeyFramer<CTrackKeyFramerLinearQuat, CKeyQuat, ILinRotKey> (ikeys,
						(CTrackKeyFramerLinearQuat*)NULL, (CKeyQuat*)NULL, (ILinRotKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(LININTERP_SCALE_CLASS_ID,0))
			{
				// For scale
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerLinearVector, CKeyVector, ILinScaleKey> (ikeys,
						(CTrackKeyFramerLinearVector*)NULL, (CKeyVector*)NULL, (ILinScaleKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}

			// ** Bezier

			if (c.ClassID()==Class_ID(HYBRIDINTERP_FLOAT_CLASS_ID,0))
			{
				// For float
				if (type==typeFloat)
					pTrack=createKeyFramer<CTrackKeyFramerBezierFloat, CKeyBezierFloat, IBezFloatKey> (ikeys,
						(CTrackKeyFramerBezierFloat*)NULL, (CKeyBezierFloat*)NULL, (IBezFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For int
				if (type==typeInt)
					pTrack=createKeyFramer<CTrackKeyFramerBezierInt, CKeyBezierFloat, IBezFloatKey> (ikeys,
						(CTrackKeyFramerBezierInt*)NULL, (CKeyBezierFloat*)NULL, (IBezFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For bool
				if (type==typeBoolean)
					pTrack=createKeyFramer<CTrackKeyFramerConstBool, CKeyBool, IBezFloatKey> (ikeys,
						(CTrackKeyFramerConstBool*)NULL, (CKeyBool*)NULL, (IBezFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if ((c.ClassID()==Class_ID(HYBRIDINTERP_POSITION_CLASS_ID,0))||
				(c.ClassID()==Class_ID(HYBRIDINTERP_POINT3_CLASS_ID,0)))
			{
				// For vector
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerBezierVector, CKeyBezierVector, IBezPoint3Key> (ikeys,
						(CTrackKeyFramerBezierVector*)NULL, (CKeyBezierVector*)NULL, (IBezPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For color
				if (type==typeColor)
					pTrack=createKeyFramer<CTrackKeyFramerBezierRGBA, CKeyBezierVector, IBezPoint3Key> (ikeys,
						(CTrackKeyFramerBezierRGBA*)NULL, (CKeyBezierVector*)NULL, (IBezPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(HYBRIDINTERP_ROTATION_CLASS_ID,0))
			{
				// For quaternion
				if (type==typeRotation)
					pTrack=createKeyFramer<CTrackKeyFramerBezierQuat, CKeyBezierQuat, IBezQuatKey> (ikeys,
						(CTrackKeyFramerBezierQuat*)NULL, (CKeyBezierQuat*)NULL, (IBezQuatKey *)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(HYBRIDINTERP_SCALE_CLASS_ID,0))
			{
				// For scale
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerBezierVector, CKeyBezierVector, IBezScaleKey> (ikeys,
						(CTrackKeyFramerBezierVector*)NULL, (CKeyBezierVector*)NULL, (IBezScaleKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(HYBRIDINTERP_COLOR_CLASS_ID,0))
			{
			}

			// ** TCB

			if (c.ClassID()==Class_ID(TCBINTERP_FLOAT_CLASS_ID,0))
			{
				// For float
				if (type==typeFloat)
					pTrack=createKeyFramer<CTrackKeyFramerTCBFloat, CKeyTCBFloat, ITCBFloatKey> (ikeys,
						(CTrackKeyFramerTCBFloat*)NULL, (CKeyTCBFloat*)NULL, (ITCBFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For int
				if (type==typeInt)
					pTrack=createKeyFramer<CTrackKeyFramerTCBInt, CKeyTCBFloat, ITCBFloatKey> (ikeys,
						(CTrackKeyFramerTCBInt*)NULL, (CKeyTCBFloat*)NULL, (ITCBFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For bool
				if (type==typeBoolean)
					pTrack=createKeyFramer<CTrackKeyFramerConstBool, CKeyBool, ITCBFloatKey> (ikeys,
						(CTrackKeyFramerConstBool*)NULL, (CKeyBool*)NULL, (ITCBFloatKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if ((c.ClassID()==Class_ID(TCBINTERP_POSITION_CLASS_ID,0))||
				(c.ClassID()==Class_ID(TCBINTERP_POINT3_CLASS_ID,0)))
			{
				// For vector
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerTCBVector, CKeyTCBVector, ITCBPoint3Key> (ikeys,
						(CTrackKeyFramerTCBVector*)NULL, (CKeyTCBVector*)NULL, (ITCBPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);

				// For color
				if (type==typeColor)
					pTrack=createKeyFramer<CTrackKeyFramerTCBRGBA, CKeyTCBVector, ITCBPoint3Key> (ikeys,
						(CTrackKeyFramerTCBRGBA*)NULL, (CKeyTCBVector*)NULL, (ITCBPoint3Key*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(TCBINTERP_ROTATION_CLASS_ID,0))
			{
				// For quaternion
				if (type==typeRotation)
					pTrack=createKeyFramer<CTrackKeyFramerTCBQuat, CKeyTCBQuat, ITCBRotKey> (ikeys,
						(CTrackKeyFramerTCBQuat*)NULL, (CKeyTCBQuat*)NULL, (ITCBRotKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}
			if (c.ClassID()==Class_ID(TCBINTERP_SCALE_CLASS_ID,0))
			{
				// For scale
				if ((type==typePos)||(type==typeScale))
					pTrack=createKeyFramer<CTrackKeyFramerTCBVector, CKeyTCBVector, ITCBScaleKey> (ikeys,
						(CTrackKeyFramerTCBVector*)NULL, (CKeyTCBVector*)NULL, (ITCBScaleKey*)NULL, ticksPerSecond, range, oRT, desc, c);
			}			
		}
	}

	// No keyframer controler
	if ((c.ClassID() == BIPSLAVE_CONTROL_CLASS_ID) ||
		bodyBiped)
	{
		NL3D::ITrack	*doomy;

		// For rotation
		if (type==typeRotation)
		{
			if (animBuildCtx)
			{
				createBipedKeyFramer (pTrack, doomy, true, false, ticksPerSecond, range, oRT, desc, *(INode*)&node, 
									animBuildCtx);
			}
		}
	}

	//if a biped body, or if must export his position track (clavicle...)
	if (bodyBiped || ( animBuildCtx && animBuildCtx->mustExportBipedBonePos((INode*)&node) ) )
	{
		NL3D::ITrack	*doomy;

		// For position
		if (type==typePos)
		{
			// 
			// Create key set
			if (animBuildCtx)
			{
				createBipedKeyFramer (doomy, pTrack, false, true, ticksPerSecond, range, oRT, desc, *(INode*)&node, 
										animBuildCtx);
			}
			else
			{
				MessageBox (NULL, _T("Warning: no pos track exported!"), _T("Tmp NEL"), MB_OK|MB_ICONEXCLAMATION);
			}
		}
	}
	
	// Return the track
	return pTrack;
}

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

bool CExportNel::getBipedKeyInfo (const char* nodeName, const char* paramName, uint key, float& res)
{
	// Make the script sequence
	char script[512];
	_snprintf (script, 512, "(biped.getKey $'%s'.controller %d).%s", nodeName, key+1, paramName);

	// Call the script
	return scriptEvaluate (script, &res, scriptFloat);
}

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

bool CExportNel::getBipedInplaceMode (const char* nodeName, const char* inplaceFunction, bool &res)
{
	// Make the script sequence
	char script[512];
	_snprintf (script, 512, "$'%s'.controller.%s", nodeName, inplaceFunction);

	// Call the script
	return scriptEvaluate (script, &res, scriptBool);
}

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

bool CExportNel::setBipedInplaceMode (const char* nodeName, const char* inplaceFunction, bool onOff)
{
	// Make the script sequence
	char script[512];
	_snprintf (script, 512, "$'%s'.controller.%s = %s", nodeName, inplaceFunction, onOff ? "true" : "false");

	// Call the script
	return scriptEvaluate (script, NULL, scriptNothing);
}

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



// ***************************************************************************
// ***************************************************************************
// Biped Oversampling.
// ***************************************************************************
// ***************************************************************************

// ***************************************************************************
void				CExportNel::buildBipedInformation(CAnimationBuildCtx &animBuildCtx, INode &node)
{
	// Parse this node and his children

	// Get the TM controler
	Control *transform=node.GetTMController();

	// Is it a biped node ?
	if ( transform && 
		(transform->ClassID() == BIPBODY_CONTROL_CLASS_ID || transform->ClassID() == BIPSLAVE_CONTROL_CLASS_ID) 
		)
	{
		// Yes, Add the node
		//===============
		CAnimationBuildCtx::CBipedNode	bipNode;
		bipNode.Node= &node;

		// add it to the array.
		animBuildCtx.BipedNodes.push_back(bipNode);


		// Update Ctx anim range
		//===============
		// Get the 3dsmax key control.
		IKeyControl *ikeys=GetKeyControlInterface (transform);

		// If has keys
		if(ikeys && ikeys->GetNumKeys()>0)
		{
			CDoomyKey key;

			// Get the first key
			ikeys->GetKey(0, &key);
			animBuildCtx.BipedRangeMin= std::min(animBuildCtx.BipedRangeMin, key.time);

			// Get the last key
			ikeys->GetKey(ikeys->GetNumKeys()-1, &key);
			animBuildCtx.BipedRangeMax= std::max(animBuildCtx.BipedRangeMax, key.time);
		}
	}

	// Parse children
	uint childrenCount=(uint)node.NumberOfChildren();
	for (uint children=0; children<childrenCount; children++)
	{
		INode *child=node.GetChildNode(children);
		buildBipedInformation (animBuildCtx, *child);
	}

}

// ***************************************************************************
void				CExportNel::overSampleBipedAnimation(CAnimationBuildCtx &animBuildCtx, uint overSampleValue)
{
	uint	i;

	// Prepare Biped bones for animation.
	//=========================

	// Bkup every bone which need to be reseted.
	std::vector<CBipedNodePlaceMode>	nodeToResetPlaceMode;

	// For all biped nodes.
	for(i=0; i<animBuildCtx.BipedNodes.size(); i++)
	{
		INode	*node= animBuildCtx.BipedNodes[i].Node;
		// Get the matrix controler
		Control *transform= node->GetTMController();
		nlassert (transform);
		nlassert (	(transform->ClassID() == BIPSLAVE_CONTROL_CLASS_ID) ||
					(transform->ClassID() == BIPBODY_CONTROL_CLASS_ID) );

		// bkup/reset InPlaceMode.
		if(transform->ClassID() == BIPBODY_CONTROL_CLASS_ID)
		{
			// Backup inplace mode
			CBipedNodePlaceMode		pm;
			pm.Node= node;
			// Backup inplace mode states
			bool res = getBipedInplaceMode (getName (*node).c_str(), "inPlaceYMode", pm.InPlaceYMode);
			nlassert (res);
			res = getBipedInplaceMode (getName (*node).c_str(), "inPlaceXMode", pm.InPlaceXMode);
			nlassert (res);
			res = getBipedInplaceMode (getName (*node).c_str(), "inPlaceMode", pm.InPlaceMode);
			nlassert (res);

			// If the node is in place mode
			if( pm.InPlaceYMode || pm.InPlaceXMode || pm.InPlaceMode )
			{
				// add to the array for restore
				nodeToResetPlaceMode.push_back(pm);

				// No inplace mode
				setBipedInplaceMode (getName (*node).c_str(), "inPlaceMode", false);
				setBipedInplaceMode (getName (*node).c_str(), "inPlaceXMode", false);
				setBipedInplaceMode (getName (*node).c_str(), "inPlaceYMode", false);
			}
		}

		//Get the Biped Export Interface from the controller 
		IBipedExport *BipIface = (IBipedExport *) transform->GetInterface(I_BIPINTERFACE);
		nlassert (BipIface);

		// Remove the non uniform scale
		BipIface->RemoveNonUniformScale(1);
	}

	// Oversample
	//=========================

	// Step for interpolation
	int interpolationStep=(overSampleValue*GetTicksPerFrame())/GetFrameRate();

	// get the number of keys to create. (ceil() and +1)
	uint	numKeys= 1 + (interpolationStep-1 + animBuildCtx.BipedRangeMax - animBuildCtx.BipedRangeMin) / interpolationStep;
	// Reserve enough space for each Biped key.
	for(i=0;i<animBuildCtx.BipedNodes.size();i++)
	{
		animBuildCtx.BipedNodes[i].Keys.reserve(numKeys);
	}

	// For each bone, true if must export his Pos track.
	std::vector<bool>	bpExportPos;
	bpExportPos.resize(animBuildCtx.BipedNodes.size());
	for(i=0;i<animBuildCtx.BipedNodes.size();i++)
	{
		bpExportPos[i]= animBuildCtx.mustExportBipedBonePos(animBuildCtx.BipedNodes[i].Node);
	}

	// For all time Values usefull for the Biped.
	TimeValue	time;
	for(time= animBuildCtx.BipedRangeMin; time<=animBuildCtx.BipedRangeMax; time+= interpolationStep)
	{
		time= std::min(animBuildCtx.BipedRangeMax, time);

		/* Do this in this way, so the Biped will be evaluated in Max only once per frame.
		*/

		// For all biped node, get their LocalMatrix.
		for(i=0;i<animBuildCtx.BipedNodes.size();i++)
		{
			CAnimationBuildCtx::CBipedNode		&bpNode= animBuildCtx.BipedNodes[i];

			// Build the key
			CAnimationBuildCtx::CBipedKey		bpKey;
			bpKey.Time= time;

			// For faster interpolation, use simpler getLocalMatrix when possible
			if( !bpExportPos[i] )
			{
				// can use it because RotQuat is the same with this method or with getNELBoneLocalTM()
				Matrix3 localTM (TRUE);
				getLocalMatrix (localTM, *bpNode.Node, time);
				// NB: with this method the NEL local pos and local scale are false, but doesn't matter since not used...
				decompMatrix (bpKey.Scale, bpKey.Quat, bpKey.Pos, localTM);
				bpKey.Quat.normalize();
			}
			else
			{
				// Get the NEL local TM, with correct position
				getNELBoneLocalTM(*bpNode.Node, time, bpKey.Scale, bpKey.Quat, bpKey.Pos);
			}

			// Add the key.
			bpNode.Keys.push_back(bpKey);
		}
	}

	// Reset Biped bones 
	//=========================

	// For all biped nodes.
	for(i=0; i<animBuildCtx.BipedNodes.size(); i++)
	{
		INode	*node= animBuildCtx.BipedNodes[i].Node;
		// Get the matrix controler
		Control *transform= node->GetTMController();
		nlassert (transform);
		nlassert (	(transform->ClassID() == BIPSLAVE_CONTROL_CLASS_ID) ||
					(transform->ClassID() == BIPBODY_CONTROL_CLASS_ID));

		//Get the Biped Export Interface from the controller 
		IBipedExport *BipIface = (IBipedExport *) transform->GetInterface(I_BIPINTERFACE);
		nlassert (BipIface);

		// Restore the non uniform scale
		BipIface->RemoveNonUniformScale(0);
	}

	// restore InPlaceMode for nodes which have been reset
	for(i=0; i<nodeToResetPlaceMode.size(); i++)
	{
		CBipedNodePlaceMode		&pm= nodeToResetPlaceMode[i];
		INode					*node= pm.Node;

		setBipedInplaceMode (getName (*node).c_str(), "inPlaceYMode", pm.InPlaceYMode);
		setBipedInplaceMode (getName (*node).c_str(), "inPlaceXMode", pm.InPlaceXMode);
		setBipedInplaceMode (getName (*node).c_str(), "inPlaceMode", pm.InPlaceMode);
	}


	// TestYoyo. To see what Pos are animated. Strange biped stuff
	//=========================
	// NB: 	for all node, you must _ExportBipedBonePosSet.insert(node) in compileBiped() to test it correctly
	/*for(i=0; i<animBuildCtx.BipedNodes.size(); i++)
	{
		CAnimationBuildCtx::CBipedNode		&bpNode= animBuildCtx.BipedNodes[i];
		if(bpNode.Keys.size()==0)
			return;

		// Test all track pos
		CVector		posRef= bpNode.Keys[0].Pos;
		for(uint j=1;j<bpNode.Keys.size();j++)
		{
			if( (bpNode.Keys[j].Pos-posRef).norm()>0.001 )
			{
				std::string	name= getName(*bpNode.Node);
				nlinfo("BipedNode %s has a Pos animation", name.c_str());
				break;
			}
		}
	}*/

}


// ***************************************************************************
CExportNel::CAnimationBuildCtx::CAnimationBuildCtx()
{
	BipedRangeMin= INT_MAX;
	BipedRangeMax= 0;
}

// ***************************************************************************
void				CExportNel::CAnimationBuildCtx::compileBiped()
{
	uint	i;

	// Build _BipedMap
	_BipedMap.clear();
	for(i=0;i<BipedNodes.size();i++)
	{
		// Add entry in map.
		_BipedMap[BipedNodes[i].Node]= i;
	}

	// Build set of bones to Export Pos Track.
	_ExportBipedBonePosSet.clear();
	for(i=0;i<BipedNodes.size();i++)
	{
		INode	*node= BipedNodes[i].Node;

		// Get the matrix controler
		Control *transform= node->GetTMController();
		nlassert (transform);
		// If this is node is a Biped controller.
		if( transform->ClassID() == BIPBODY_CONTROL_CLASS_ID )
		{
			// Add him to the set.
			_ExportBipedBonePosSet.insert(node);

			// Must add some important limbs of this biped too (Biped stuff => sometimes pos are animated).
			addLimbNodeToExportPos(node, "#larm");
			addLimbNodeToExportPos(node, "#rarm");
			addLimbNodeToExportPos(node, "#spine");
			addLimbNodeToExportPos(node, "#tail");
		}
	}
}


// ***************************************************************************
void				CExportNel::CAnimationBuildCtx::addLimbNodeToExportPos(INode *rootNode, const char *limbId)
{
	char script[512];
	INode		*limbNode= NULL;

	// evaluate script.
	_snprintf (script, 512, "biped.getNode $'%s' %s", CExportNel::getName(*rootNode).c_str(), limbId);
	// If script is ok.
	if( CExportNel::scriptEvaluate (script, &limbNode, scriptNode) )
	{
		// add to the array if success
		if(limbNode)
			_ExportBipedBonePosSet.insert(limbNode);
	}
}


// ***************************************************************************
CExportNel::CAnimationBuildCtx::CBipedNode		*CExportNel::CAnimationBuildCtx::getBipedNodeInfo(INode *node)
{
	TBipedMap::const_iterator	it= _BipedMap.find(node);
	if(it==_BipedMap.end())
		return NULL;
	else
		return &BipedNodes[it->second];
}


// ***************************************************************************
bool				CExportNel::CAnimationBuildCtx::mustExportBipedBonePos(INode *node)
{
	// true if found in the set.
	return (_ExportBipedBonePosSet.find(node)!=_ExportBipedBonePosSet.end());
}


// ***************************************************************************
struct CSpawnCmd 
{
	std::string		Cmd;
	std::string		Shape;
	std::string		Bone;

	bool	operator<(const CSpawnCmd &o) const
	{
		if(Shape!=o.Shape)
			return Shape<o.Shape;
		if(Cmd!=o.Cmd)
			return Cmd<o.Cmd;
		return Bone<o.Bone;
	}
};
struct CSpawnObject
{
	uint	FinalId;
	bool	Spawned;

	CSpawnObject()
	{
		FinalId= 0;
		Spawned= false;
	}
};


static void commitSSSKey(NL3D::TAnimationTime keyTime, std::map<CSpawnCmd, CSpawnObject> &objects, CTrackKeyFramerConstString *finalTrack, bool &insertedAt0)
{
	CKeyString		keyValue;
	
	// The final script is "state script" oriented
	// ie, generate a line for each spawned object, not for each command!
	std::map<CSpawnCmd, CSpawnObject>::iterator		it;
	for(it= objects.begin();it!=objects.end();it++)
	{
		// if the object is spawn, add a line
		if(it->second.Spawned)
		{
			if(it->first.Cmd=="lspawn")
			{
				keyValue.Value+= toString("objl %d %s %s\n", it->second.FinalId, it->first.Shape.c_str(), it->first.Bone.c_str());
			}
			else if(it->first.Cmd=="wspawn")
			{
				keyValue.Value+= toString("objw %d %s\n", it->second.FinalId, it->first.Shape.c_str());
			}
		}
	}

	// add to the track
	finalTrack->addKey(keyValue, keyTime);

	if(keyTime==0)
		insertedAt0= true;
}

void				CSSSBuild::compile(NL3D::CAnimation &dest, const char* sBaseName)
{
	// no script?
	if(Bones.empty())
		return;

	/*	Take each script at each bone, and generate only ONE script (the global script), 
		that will be attached to the animation
	*/

	// list of unique object
	std::map<CSpawnCmd, CSpawnObject>			objects;
	uint										numObjs= 0;

	// timeline of cmds
	std::multimap<NL3D::TAnimationTime, CSpawnCmd>	keys;


	// **** first pass. compute set of objects, and generate keys timeline
	uint i;
	for(i=0;i<Bones.size();i++)
	{
		CSSSBuild::CBoneScript				&bone= Bones[i];
		// "compile" script at each key
		for(uint j=0;j<bone.Track.size();j++)
		{
			std::string		&script= bone.Track[j].Value;
			// at each key, there can't be the same shape to create
			std::set<CSpawnCmd>	keySet;
			
			// parse each line of the script
			static std::vector<std::string>		lines;
			lines.clear();
			splitString(script, "\n", lines);
			for(uint k=0;k<lines.size();k++)
			{
				std::string	&line= lines[k];

				// remove any '\r'
				line.resize( std::remove_if(line.begin(), line.end(), std::bind2nd(std::equal_to<char>(), '\r') )
					- line.begin() );

				// parse
				static std::vector<std::string>		words;
				words.clear();
				splitString(line, " ", words);
				
				if(words.size()>=2)
				{
					bool	ok= false;
					if(words[0]=="wspawn")		ok= true;
					else if(words[0]=="lspawn")	ok= true;
					else if(words[0]=="wkill")		ok= true;
					else if(words[0]=="lkill")	ok= true;
					
					// if valid command
					if(ok)
					{
						CSpawnCmd	oi;
						oi.Cmd= words[0];
						oi.Shape= words[1];
						// lower to avoid case error, and append .shape
						strlwr(oi.Shape);
						if(oi.Shape.find('.')==std::string::npos)
							oi.Shape+= ".shape";
						// bone name
						oi.Bone= bone.BoneName;
						// valid if the command does not exist in the current key
						if(keySet.insert(oi).second)
						{
							// if the command is not a kill, insert in the object list
							if(oi.Cmd!="wkill" && oi.Cmd!="lkill")
							{
								// insert if not already done
								if(objects.find(oi)==objects.end())
								{
									objects[oi].FinalId= numObjs++;
								}
							}
							// insert a cmd key at this key time
							keys.insert(std::make_pair(bone.Track[j].Time, oi));
						}
					}
				}
			}
		}
	}

	// **** second pass, genereate the global script animation
	// create the final track
	CTrackKeyFramerConstString		*finalTrack= new CTrackKeyFramerConstString;
	// parse each key in the chronogical order
	NL3D::TAnimationTime	precTime= 0;
	bool					firstKey= true;
	bool					insertedAt0= false;
	std::multimap<NL3D::TAnimationTime, CSpawnCmd>::iterator		kit;
	for(kit= keys.begin();kit!=keys.end();kit++)
	{
		NL3D::TAnimationTime	keyTime= kit->first;
		CSpawnCmd				keyValue= kit->second;


		// ---- if the keyTime has changed, then commit the last key
		if(!firstKey && precTime!=keyTime)
		{
			commitSSSKey(precTime, objects, finalTrack, insertedAt0);
			// new key to create
			precTime= keyTime;
		}
		// no more first key
		if(firstKey)
			firstKey= false;
		// for next loop
		precTime= keyTime;
		

		// ---- update object state, according to the key cmd
		std::map<CSpawnCmd, CSpawnObject>::iterator		oit;
		bool	isSpawn;
		if(keyValue.Cmd=="wspawn" || keyValue.Cmd=="lspawn")
			isSpawn= true;
		else
		{
			isSpawn= false;
			// Find the associated object if a kill => replace kill by spawn
			if(keyValue.Cmd=="wkill")	keyValue.Cmd="wspawn";
			if(keyValue.Cmd=="lkill")	keyValue.Cmd="lspawn";
		}
		oit= objects.find(keyValue);
		// NB: may not be found, if a kill has a bad ShapeName
		if(oit!=objects.end())
		{
			// spawn or kill?
			if(isSpawn)
				oit->second.Spawned= true;
			else
				oit->second.Spawned= false;
		}
	}

	// if some keys added
	if(!firstKey)
	{
		// comit the last key
		commitSSSKey(precTime, objects, finalTrack, insertedAt0);

		// If none has been inserted at 0, must add an empty key at 0
		if(!insertedAt0)
		{
			CKeyString		keyValue;
			finalTrack->addKey(keyValue, 0);
		}
	}
	else
	{
		// no keys added
		delete finalTrack;
		finalTrack = NULL;
	}
		

	// **** Add to the animation
	if(finalTrack)
	{
		// ---- add the track
		std::string		name= std::string(sBaseName) + NL3D::CSkeletonModel::getSpawnScriptValueName();
		dest.addTrack(name, finalTrack);

		// ---- must also inform the animation of all shapes it can spawn
		std::set<std::string>	shapeSet;
		std::map<CSpawnCmd, CSpawnObject>::iterator		oit;

		// remove shape duplicate from cmd
		for(oit= objects.begin();oit!=objects.end();oit++)
			shapeSet.insert(oit->first.Shape);

		// then for each, insert in the animation
		std::set<std::string>::iterator		it;
		for(it=shapeSet.begin();it!=shapeSet.end();it++)
			dest.addSSSShape(*it);
	}
}