// TnzCore includes

#include "tstream.h"

// TnzBase includes

#include "tdoublekeyframe.h"

#include "tparamchange.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

#include "ext/plasticdeformerstorage.h"

// tcg includes

#include "tcg/tcg_misc.h"

#include "tcg/tcg_function_types.h"

// STL includes

#include <memory></memory>

#include <set></set>

#include <map></map>

// Boost includes

#include <boost bimap.hpp=""></boost>

#include <boost multi_index_container.hpp=""></boost>

#include <boost multi_index="" ordered_index.hpp=""></boost>

#include <boost member.hpp="" multi_index=""></boost>

#include <boost iterator="" transform_iterator.hpp=""></boost>

#include "ext/plasticskeletondeformation.h"

PERSIST_IDENTIFIER(PlasticSkeletonVertexDeformation, "PlasticSkeletonVertexDeformation")

PERSIST_IDENTIFIER(PlasticSkeletonDeformation, "PlasticSkeletonDeformation")

DEFINE_CLASS_CODE(PlasticSkeletonDeformation, 121)

//**************************************************************************************

//    Boost-related  stuff

//**************************************************************************************

using namespace boost::multi_index;

namespace

{

typedef boost::bimap<int, plasticskeletonp=""> SkeletonSet;</int,>

//======================================================================

struct VDKey {

	QString m_name;

	int m_hookNumber;

	mutable std::map<int, int=""> m_vIndices; //!< Skeleton index to Vertex index map</int,>

	mutable SkVD m_vd;

};

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

typedef boost::multi_index_container

												ordered_unique<tag<qstring>, member<vdkey, &vdkey::m_name="" qstring,="">>,</vdkey,></tag<qstring>

												ordered_unique<tag<int>, member<vdkey, &vdkey::m_hooknumber="" int,="">></vdkey,></tag<int>

												>> SkVDSet;

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

typedef SkVDSet::index<int>::type SkVDByHookNumber;</int>

} // namespace

//**************************************************************************************

//    Local  namespace

//**************************************************************************************

namespace

{

static const char *parNames[SkVD::PARAMS_COUNT] = {"Angle", "Distance", "SO"};

static const char *parMeasures[SkVD::PARAMS_COUNT] = {"angle", "fxLength", ""};

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

// Extract the angle between edges vParent->v and vGrandParent->vParent

double buildAngle(const PlasticSkeleton &skeleton, int v)

{

	const PlasticSkeletonVertex &vx = skeleton.vertex(v);

	int vParent = vx.parent();

	assert(vx.parent() >= 0);

	const PlasticSkeletonVertex &vxParent = skeleton.vertex(vParent);

	int vGrandParent = vxParent.parent();

	// Build reference orientation

	TPointD dir(1.0, 0.0); // Standard horizontal axis if no grandParent

	if (vGrandParent >= 0) {

		// Relative orientation

		const PlasticSkeletonVertex &vxGrandParent = skeleton.vertex(vGrandParent);

		dir = vxParent.P() - vxGrandParent.P();

	}

	return tcg::consts::rad_to_deg * tcg::point_ops::angle(dir, vx.P() - vxParent.P());

}

} // namespace

//**************************************************************************************

//    PlasticSkeletonVertex  implementation

//**************************************************************************************

SkVD::Keyframe SkVD::getKeyframe(double frame) const

{

	Keyframe kf;

	for (int p = 0; p < PARAMS_COUNT; ++p)

		kf.m_keyframes[p] = m_params[p]->getKeyframeAt(frame);

	return kf;

}

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

void SkVD::setKeyframe(double frame)

{

	for (int p = 0; p < PARAMS_COUNT; ++p)

		m_params[p]->setKeyframe(m_params[p]->getKeyframeAt(frame));

}

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

bool SkVD::setKeyframe(const SkVD::Keyframe &values)

{

	bool keyWasSet = false;

	for (int p = 0; p < PARAMS_COUNT; ++p)

		if (values.m_keyframes[p].m_isKeyframe) {

			m_params[p]->setKeyframe(values.m_keyframes[p]);

			keyWasSet = true;

		}

	return keyWasSet;

}

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

bool SkVD::setKeyframe(

	const SkVD::Keyframe &values, double frame, double easeIn, double easeOut)

{

	bool keyWasSet = false;

	for (int p = 0; p < PARAMS_COUNT; ++p)

		if (values.m_keyframes[p].m_isKeyframe) {

			TDoubleKeyframe kf(values.m_keyframes[p]);

			kf.m_frame = frame;

			if (easeIn >= 0.0)

				kf.m_speedIn = TPointD(-easeIn, kf.m_speedIn.y);

			if (easeOut >= 0.0)

				kf.m_speedOut = TPointD(easeOut, kf.m_speedOut.y);

			m_params[p]->setKeyframe(kf);

			keyWasSet = true;

		}

	return keyWasSet;

}

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

bool SkVD::isKeyframe(double frame) const

{

	for (int p = 0; p < PARAMS_COUNT; ++p)

		if (m_params[p]->isKeyframe(frame))

			return true;

	return false;

}

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

bool SkVD::isFullKeyframe(double frame) const

{

	for (int p = 0; p < PARAMS_COUNT; ++p)

		if (!m_params[p]->isKeyframe(frame))

			return false;

	return true;

}

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

void SkVD::deleteKeyframe(double frame)

{

	for (int p = 0; p < PARAMS_COUNT; ++p)

		m_params[p]->deleteKeyframe(frame);

}

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

void SkVD::saveData(TOStream &os)

{

	for (int p = 0; p < PARAMS_COUNT; ++p)

		if (!m_params[p]->isDefault())

			os.child(::parNames[p]) << *m_params[p];

}

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

void SkVD::loadData(TIStream &is)

{

	std::string tagName;

	while (is.matchTag(tagName)) {

		int p;

		for (p = 0; p < PARAMS_COUNT; ++p) {

			if (tagName == parNames[p]) {

				is >> *m_params[p], is.matchEndTag();

				break;

			}

		}

		if (p >= PARAMS_COUNT)

			is.skipCurrentTag();

	}

}

//**************************************************************************************

//    PlasticSkeletonDeformation::Imp  definition

//**************************************************************************************

class PlasticSkeletonDeformation::Imp : public TParamObserver

{

public:

	PlasticSkeletonDeformation *m_back; //!< Back-pointer to the interface class

	SkeletonSet m_skeletons; //!< Skeletons owned by the deformation

	SkVDSet m_vds;			 //!< Container of vertex deformations

	TDoubleParamP m_skelIdsParam; //!< Curve of skeleton ids by xsheet frame

	std::set<tparamobserver *=""> m_observers; //!< Set of the deformation's observers</tparamobserver>

	TSyntax::Grammar *m_grammar; //!< The params' grammar. Weird though - it's a VERY

								 //!< occult requirement to TDoubleParams...

	// NOTE: There \a is a deformation even for a skeleton's root node. This is now required due to the

	// onwership of \a multiple skeletons at once. However, its angle and distance params will be unused.

public:

	Imp(PlasticSkeletonDeformation *back);

	~Imp();

	Imp(PlasticSkeletonDeformation *back, const Imp &other);

	Imp &operator=(const Imp &other);

	PlasticSkeleton &skeleton(int skelId) const;

	SkVD &vertexDeformation(const QString &name) const;

	void attach(int skeletonId, PlasticSkeleton *skeleton);

	void detach(int skeletonId);

	void attachVertex(const QString &name, int skelId, int v);

	void detachVertex(const QString &name, int skelId, int v);

	void rebindVertex(const QString &name, int skelId, const QString &newName);

	void touchParams(SkVD &vd);

	//! Applies stored vertex deformations to the skeleton branch starting at v

	void updateBranchPositions(

		const PlasticSkeleton &originalSkeleton, PlasticSkeleton &deformedSkeleton,

		double frame, int v);

	void onChange(const TParamChange &change); // Passes param notifications to external observers

private:

	// Not directly copy-constructible

	Imp(const Imp &other);

};

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

PlasticSkeletonDeformation::Imp::Imp(PlasticSkeletonDeformation *back)

	: m_back(back), m_skelIdsParam(1.0), m_grammar()

{

	m_skelIdsParam->setName("Skeleton Id");

	m_skelIdsParam->addObserver(this);

}

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

PlasticSkeletonDeformation::Imp::~Imp()

{

	m_skelIdsParam->removeObserver(this);

	SkVDSet::iterator dt, dEnd(m_vds.end());

	for (dt = m_vds.begin(); dt != dEnd; ++dt)

		for (int p = 0; p < SkVD::PARAMS_COUNT; ++p)

			dt->m_vd.m_params[p]->removeObserver(this);

}

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

PlasticSkeletonDeformation::Imp::Imp(PlasticSkeletonDeformation *back, const Imp &other)

	: m_back(back), m_skelIdsParam(other.m_skelIdsParam->clone()), m_grammar()

{

	m_skelIdsParam->setGrammar(m_grammar);

	m_skelIdsParam->addObserver(this);

	// Clone the skeletons

	SkeletonSet::const_iterator st, sEnd(other.m_skeletons.end());

	for (st = other.m_skeletons.begin(); st != sEnd; ++st)

		m_skeletons.insert(SkeletonSet::value_type(

			st->get_left(), new PlasticSkeleton(*st->get_right())));

	// Clone each parameters curve

	SkVD vd;

	SkVDSet::const_iterator dt, dEnd(other.m_vds.end());

	for (dt = other.m_vds.begin(); dt != dEnd; ++dt) {

		VDKey vdKey = {dt->m_name, dt->m_hookNumber, dt->m_vIndices};

		for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

			TDoubleParamP ¶m = vdKey.m_vd.m_params[p];

			param = TDoubleParamP(dt->m_vd.m_params[p]->clone());

			param->setGrammar(m_grammar);

			param->addObserver(this);

		}

		m_vds.insert(vdKey);

	}

}

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

PlasticSkeletonDeformation::Imp &PlasticSkeletonDeformation::Imp::operator=(const Imp &other)

{

	*m_skelIdsParam = *other.m_skelIdsParam;

	m_skelIdsParam->setGrammar(m_grammar);

	// Take in all curves whose name matches one of the stored ones

	// Traverse known curves

	SkVDSet::iterator dt, dEnd(m_vds.end());

	SkVDSet::const_iterator st, sEnd(other.m_vds.end());

	for (dt = m_vds.begin(); dt != dEnd; ++dt) {

		// Search a corresponding curve in the input ones

		st = other.m_vds.find(dt->m_name);

		if (st != sEnd)

			for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

				TDoubleParam ¶m = *dt->m_vd.m_params[p];

				param = *st->m_vd.m_params[p];

				param.setGrammar(m_grammar);

			}

	}

	return *this;

}

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

PlasticSkeleton &PlasticSkeletonDeformation::Imp::skeleton(int skelId) const

{

	SkeletonSet::left_map::const_iterator st(m_skeletons.left.find(skelId));

	assert(st != m_skeletons.left.end());

	return *st->second;

}

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

SkVD &PlasticSkeletonDeformation::Imp::vertexDeformation(const QString &name) const

{

	SkVDSet::const_iterator vdt(m_vds.find(name));

	assert(vdt != m_vds.end());

	return vdt->m_vd;

}

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

void PlasticSkeletonDeformation::Imp::attach(int skeletonId, PlasticSkeleton *skeleton)

{

	assert(skeleton);

	// Store the skeleton - acquires shared ownership

	assert(m_skeletons.left.find(skeletonId) == m_skeletons.left.end());

	m_skeletons.insert(SkeletonSet::value_type(skeletonId, skeleton));

	// Deal with vertex deformations and parameter defaults

	tcg::list<plasticskeleton::vertex_type> &vertices = skeleton->vertices();</plasticskeleton::vertex_type>

	if (!vertices.empty()) {

		tcg::list<plasticskeletonvertex>::iterator vt, vEnd(vertices.end());</plasticskeletonvertex>

		for (vt = vertices.begin(); vt != vEnd; ++vt)

			attachVertex(vt->name(), skeletonId, vt.index());

	}

}

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

void PlasticSkeletonDeformation::Imp::detach(int skeletonId)

{

	// First, detach all vertices

	tcg::list<plasticskeleton::vertex_type> &vertices = skeleton(skeletonId).vertices();</plasticskeleton::vertex_type>

	if (!vertices.empty()) {

		tcg::list<plasticskeletonvertex>::iterator vt, vEnd(vertices.end());</plasticskeletonvertex>

		for (vt = vertices.begin(); vt != vEnd; ++vt)

			detachVertex(vt->name(), skeletonId, vt.index());

	}

	// Then, release the skeleton itself

	m_skeletons.left.erase(skeletonId);

}

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

void PlasticSkeletonDeformation::Imp::attachVertex(const QString &name, int skelId, int v)

{

	struct locals {

		static int newHookNumber(Imp *imp)

		{

			int h = 1;

			SkVDByHookNumber::iterator vdt, vdEnd(imp->m_vds.get<int>().end());</int>

			for (vdt = imp->m_vds.get<int>().begin(); vdt != vdEnd && vdt->m_hookNumber == h; ++vdt, ++h)</int>

				;

			return h;

		}

	}; // locals

	// Insert a new VD if necessary

	SkVDSet::iterator vdt(m_vds.find(name));

	if (vdt == m_vds.end()) {

		VDKey vdKey = {name, locals::newHookNumber(this)};

		touchParams(vdKey.m_vd);

		vdt = m_vds.insert(vdKey).first;

	}

	// Register (skelId, v) on the vd

	vdt->m_vIndices.insert(std::make_pair(skelId, v));

}

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

void PlasticSkeletonDeformation::Imp::detachVertex(const QString &name, int skelId, int v)

{

	SkVDSet::iterator vdt = m_vds.find(name);

	assert(vdt != m_vds.end());

	// Unregister skelId

	int count = vdt->m_vIndices.erase(skelId);

	assert(count > 0);

	if (vdt->m_vIndices.empty()) {

		// De-register as vdt's observer, and release it from stored vds

		SkVD &vd = vdt->m_vd;

		for (int p = 0; p < SkVD::PARAMS_COUNT; ++p)

			vd.m_params[p]->removeObserver(this);

		m_vds.erase(vdt);

	}

}

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

void PlasticSkeletonDeformation::Imp::rebindVertex(

	const QString &name, int skelId, const QString &newName)

{

	if (name == newName)

		return;

	SkVDSet::iterator oldVdt = m_vds.find(name);

	if (oldVdt == m_vds.end())

		return; // We get here when creating a new vertex

	std::map<int, int="">::iterator vit = oldVdt->m_vIndices.find(skelId);</int,>

	assert(vit != oldVdt->m_vIndices.end());

	int v = vit->second;

	SkVDSet::iterator newVdt = m_vds.find(newName);

	if (newVdt != m_vds.end()) {

		detachVertex(name, skelId, v);

		attachVertex(newName, skelId, v);

	} else {

		// Creating a new vd entry

		if (oldVdt->m_vIndices.size() == 1) {

			// The old entry should be removed - it is actually *purely* renamed

			VDKey vdKey(*oldVdt);

			vdKey.m_name = newName;

			m_vds.erase(name);

			m_vds.insert(vdKey);

		} else {

			// The old entry remains - and data must be copied from there

			detachVertex(name, skelId, v);

			attachVertex(newName, skelId, v);

			newVdt = m_vds.find(newName); // Fetch the newly created vd

			// Copy the existing vd into the new one

			SkVD &oldVd = oldVdt->m_vd, &newVd = newVdt->m_vd;

			int p, pCount = SkVD::PARAMS_COUNT;

			for (p = 0; p != pCount; ++p)

				*newVd.m_params[p] = *oldVd.m_params[p];

		}

	}

}

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

void PlasticSkeletonDeformation::Imp::touchParams(SkVD &vd)

{

	for (int p = 0; p < SkVD::PARAMS_COUNT; ++p) {

		if (vd.m_params[p])

			continue;

		TDoubleParam *param = new TDoubleParam;

		param->setName(parNames[p]);

		param->setMeasureName(parMeasures[p]);

		param->setGrammar(m_grammar);

		vd.m_params[p] = param;

		param->addObserver(this);

	}

}

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

void PlasticSkeletonDeformation::Imp::onChange(const TParamChange &change)

{

	// Since the deformation was changed, any associated deformer

	// must be invalidated (at the animation-deform level only)

	PlasticDeformerStorage::instance()->invalidateDeformation(

		m_back, PlasticDeformerStorage::NONE);

	// Propagate notification to this object's observers

	std::set<tparamobserver *="">::iterator ot, oEnd(m_observers.end());</tparamobserver>

	for (ot = m_observers.begin(); ot != oEnd; ++ot)

		(*ot)->onChange(change);

}

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

void PlasticSkeletonDeformation::Imp::updateBranchPositions(

	const PlasticSkeleton &originalSkeleton, PlasticSkeleton &deformedSkeleton,

	double frame, int v)

{

	struct locals {

		static void buildParentDirection(const PlasticSkeleton &skel, int v, TPointD &dir)

		{

			assert(v >= 0);

			const PlasticSkeletonVertex &vx = skel.vertex(v);

			int vParent = vx.parent();

			if (vParent < 0)

				return; // dir remains as passed

			const TPointD &dir_ = tcg::point_ops::direction(

				skel.vertex(vParent).P(), vx.P(), 1e-4);

			if (dir_ != tcg::point_ops::NaP<tpointd>())</tpointd>

				dir = dir_;

			else

				buildParentDirection(skel, vParent, dir);

		}

	}; // locals

	PlasticSkeletonVertex &dvx = deformedSkeleton.vertex(v);

	int vParent = dvx.parent();

	if (vParent >= 0) {

		// Rebuild vertex position

		const TPointD &ovxPos = originalSkeleton.vertex(v).P();

		const TPointD &ovxParentPos = originalSkeleton.vertex(vParent).P();

		// Start by getting the polar reference

		TPointD oDir(1.0, 0.0), dDir(1.0, 0.0);

		locals::buildParentDirection(originalSkeleton, vParent, oDir);

		locals::buildParentDirection(deformedSkeleton, vParent, dDir);

		// Now, rebuild vx's position

		const SkVD &vd = m_vds.find(dvx.name())->m_vd;

		double a = tcg::consts::rad_to_deg * tcg::point_ops::angle(oDir, ovxPos - ovxParentPos);

		double d = tcg::point_ops::dist(ovxParentPos, ovxPos);

		double aDelta = vd.m_params[SkVD::ANGLE]->getValue(frame);

		double dDelta = vd.m_params[SkVD::DISTANCE]->getValue(frame);

		dvx.P() = deformedSkeleton.vertex(vParent).P() +

				  (d + dDelta) * (TRotation(a + aDelta) * dDir);

	}

	// Finally, update children positions

	PlasticSkeleton::vertex_type::edges_iterator et, eEnd(dvx.edgesEnd());

	for (et = dvx.edgesBegin(); et != eEnd; ++et) {

		int vChild = deformedSkeleton.edge(*et).vertex(1);

		if (vChild == v)

			continue;

		updateBranchPositions(originalSkeleton, deformedSkeleton, frame, vChild);

	}

}

//**************************************************************************************

//    PlasticSkeletonDeformation  implementation

//**************************************************************************************

PlasticSkeletonDeformation::PlasticSkeletonDeformation()

	: m_imp(new Imp(this))

{

}

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

PlasticSkeletonDeformation::PlasticSkeletonDeformation(const PlasticSkeletonDeformation &other)

	: TSmartObject(m_classCode), m_imp(new Imp(this, *other.m_imp))

{

	// Register deformation

	SkeletonSet::iterator st, sEnd(m_imp->m_skeletons.end());

	for (st = m_imp->m_skeletons.begin(); st != sEnd; ++st)

		st->get_right()->addListener(this);

}

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

PlasticSkeletonDeformation::~PlasticSkeletonDeformation()

{

	// Unregister deformation

	SkeletonSet::iterator st, sEnd(m_imp->m_skeletons.end());

	for (st = m_imp->m_skeletons.begin(); st != sEnd; ++st)

		st->get_right()->removeListener(this);

}

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

PlasticSkeletonDeformation &PlasticSkeletonDeformation::operator=(const PlasticSkeletonDeformation &other)

{

	// The meaning of operator= is DIFFERENT from that implemented in the copy constructor.

	// Skeletons are NOT cloned.

	*m_imp = *other.m_imp;

	return *this;

}

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

bool PlasticSkeletonDeformation::empty() const

{

	return m_imp->m_skeletons.empty();

}

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

int PlasticSkeletonDeformation::skeletonsCount() const

{

	return m_imp->m_skeletons.size();

}

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

namespace

{

namespace skeletonIds

{

typedef boost::bimap<int, plasticskeletonp="">::left_map::const_iterator iter_type;</int,>

typedef iter_type::value_type value_type;

inline int func_(const value_type &val) { return val.first; }

}

} // namespace ::skeletonIds

void PlasticSkeletonDeformation::skeletonIds(skelId_iterator &begin, skelId_iterator &end) const

{

	using namespace ::skeletonIds;

	typedef tcg::function<int &),="" (*)(const="" func_="" value_type=""> func;</int>

	typedef boost::transform_iterator<func, iter_type=""> adapt_it;</func,>

	begin = adapt_it(m_imp->m_skeletons.left.begin());

	end = adapt_it(m_imp->m_skeletons.left.end());

}

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

TDoubleParamP PlasticSkeletonDeformation::skeletonIdsParam() const

{

	return m_imp->m_skelIdsParam;

}

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

PlasticSkeletonP PlasticSkeletonDeformation::skeleton(double frame) const

{

	return skeleton(skeletonId(frame));

}

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

int PlasticSkeletonDeformation::skeletonId(double frame) const

{

	return m_imp->m_skelIdsParam->getValue(frame);

}

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

void PlasticSkeletonDeformation::attach(int skeletonId, PlasticSkeleton *skeleton)

{

	m_imp->attach(skeletonId, skeleton);

	skeleton->addListener(this);

}

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

void PlasticSkeletonDeformation::detach(int skeletonId)

{

	SkeletonSet::left_map::iterator st(m_imp->m_skeletons.left.find(skeletonId));

	if (st != m_imp->m_skeletons.left.end()) {

		st->second->removeListener(this);

		m_imp->detach(skeletonId);

	}

}

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

PlasticSkeletonP PlasticSkeletonDeformation::skeleton(int skeletonId) const

{

	SkeletonSet::left_map::const_iterator st = m_imp->m_skeletons.left.find(skeletonId);

	return (st == m_imp->m_skeletons.left.end()) ? PlasticSkeletonP() : st->second;

}

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

int PlasticSkeletonDeformation::skeletonId(PlasticSkeleton *skeleton) const

{

	SkeletonSet::right_map::const_iterator st = m_imp->m_skeletons.right.find(skeleton);

	return (st == m_imp->m_skeletons.right.end()) ? -(std::numeric_limits<int>::max)() : st->second;</int>

}

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

int PlasticSkeletonDeformation::vertexDeformationsCount() const

{

	return m_imp->m_vds.size();

}

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

SkVD *PlasticSkeletonDeformation::vertexDeformation(const QString &vxName) const

{

	SkVDSet::const_iterator vdt = m_imp->m_vds.find(vxName);

	return (vdt == m_imp->m_vds.end()) ? (SkVD *)0 : &vdt->m_vd;

}

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

SkVD *PlasticSkeletonDeformation::vertexDeformation(int skelId, int v) const

{

	const QString &name = skeleton(skelId)->vertex(v).name();

	return vertexDeformation(name);

}

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

namespace

{

namespace vertexDeformations

{

inline std::pair<const *="" *,="" qstring="" skvd=""> func_(const VDKey &vdKey)</const>

{

	return std::make_pair(&vdKey.m_name, &vdKey.m_vd);

}

}

} // namespace ::vertexDeformations

void PlasticSkeletonDeformation::vertexDeformations(vd_iterator &begin, vd_iterator &end) const

{

	using namespace ::vertexDeformations;

	typedef std::pair<const *="" *,="" qstring="" skvd=""> (*func_type)(const VDKey &vdKey);</const>

	typedef tcg::function<func_type, func_=""> func;</func_type,>

	typedef boost::transform_iterator<func, skvdset::const_iterator=""> adapt_it;</func,>

	begin = adapt_it(m_imp->m_vds.begin());

	end = adapt_it(m_imp->m_vds.end());

}

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

namespace

{

namespace vdSkeletonVertices

{

inline std::pair<int, int=""> func_(const std::map<int, int="">::value_type &val)</int,></int,>

{

	return std::make_pair(val.first, val.second);

}

}

} // namespace ::vdSkeletonVertices

void PlasticSkeletonDeformation::vdSkeletonVertices(const QString &vertexName,

													vx_iterator &begin, vx_iterator &end) const

{

	using namespace ::vdSkeletonVertices;

	typedef std::pair<int, int=""> (*func_type)(const std::map<int, int="">::value_type &);</int,></int,>

	typedef tcg::function<func_type, func_=""> func;</func_type,>

	typedef boost::transform_iterator<func, int="" std::map<int,="">::const_iterator> adapt_it;</func,>

	SkVDSet::const_iterator nt(m_imp->m_vds.find(vertexName));

	if (nt == m_imp->m_vds.end())

		begin = adapt_it(), end = adapt_it();

	else

		begin = adapt_it(nt->m_vIndices.begin()), end = adapt_it(nt->m_vIndices.end());

}

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

int PlasticSkeletonDeformation::hookNumber(const QString &name) const

{

	SkVDSet::const_iterator nt(m_imp->m_vds.find(name));

	return (nt == m_imp->m_vds.end()) ? -1 : nt->m_hookNumber;

}

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

int PlasticSkeletonDeformation::hookNumber(int skelId, int v) const

{

	const QString &name = skeleton(skelId)->vertex(v).name();

	return hookNumber(name);

}

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

QString PlasticSkeletonDeformation::vertexName(int hookNumber) const

{

	const SkVDByHookNumber &vds = m_imp->m_vds.get<int>();</int>

	SkVDByHookNumber::const_iterator ht(vds.find(hookNumber));

	return (ht == vds.end()) ? QString() : ht->m_name;

}

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

int PlasticSkeletonDeformation::vertexIndex(int hookNumber, int skelId) const

{

	const SkVDByHookNumber &vds = m_imp->m_vds.get<int>();</int>

	SkVDByHookNumber::const_iterator ht(vds.find(hookNumber));

	if (ht == vds.end())

		return -1;

	std::map<int, int="">::const_iterator st(ht->m_vIndices.find(skelId));</int,>

	return (st == ht->m_vIndices.end()) ? -1 : st->second;

}

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

void PlasticSkeletonDeformation::getKeyframeAt(double frame, SkDKey &keyframe) const

{

	keyframe.m_skelIdKeyframe = m_imp->m_skelIdsParam->getKeyframeAt(frame);

	keyframe.m_vertexKeyframes.clear();