#include "toonz/tstageobject.h"

// TnzLib includes

#include "toonz/tstageobjecttree.h"

#include "toonz/tstageobjectspline.h"

#include "toonz/txsheet.h"

#include "toonz/observer.h"

#include "toonz/txshlevelcolumn.h"

#include "toonz/txshcell.h"

#include "toonz/stage.h"

#include "toonz/tcamera.h"

#include "toonz/doubleparamcmd.h"

#include "toonz/tpinnedrangeset.h"

// TnzExt includes

#include "ext/plasticskeleton.h"

#include "ext/plasticskeletondeformation.h"

#include "ext/plasticdeformerstorage.h"

// TnzCore includes

#include "tstream.h"

#include "tstroke.h"

#include "tconvert.h"

#include "tundo.h"

#include "tconst.h"

// Qt includes

#include <qmetaobject></qmetaobject>

// tcg includes

#include "tcg/tcg_function_types.h"

// STD includes

#include <fstream></fstream>

#include <set></set>

using namespace std;

//

// Per un problema su alcune macchine, solo Release.

// il problema si verifica ruotando gli oggetti sul camera stand

//

#ifdef _WIN32

#pragma optimize("", off)

#endif

TAffine makeRotation(double ang)

{

	return TRotation(ang);

}

#ifdef _WIN32

#pragma optimize("", on)

#endif

DEFINE_CLASS_CODE(TStageObject, 102)

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

//    Local namespace

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

namespace

{

enum StageObjectType {

	NONE = 0,

	CAMERA = 1,

	TABLE = 2,

	PEGBAR = 5,

	COLUMN = 6

};

const int StageObjectTypeShift = 28;

const int StageObjectMaxIndex = ((1 << StageObjectTypeShift) - 1);

const int StageObjectIndexMask = ((1 << StageObjectTypeShift) - 1);

} // namespace

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

//    TStageObjectParams  implementation

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

TStageObjectParams::TStageObjectParams()

	: m_spline(0), m_noScaleZ(0)

{

}

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

TStageObjectParams::TStageObjectParams(TStageObjectParams *data)

	: m_id(data->m_id), m_parentId(data->m_parentId), m_children(data->m_children), m_keyframes(data->m_keyframes), m_cycleEnabled(data->m_cycleEnabled), m_spline(data->m_spline), m_status(data->m_status), m_handle(data->m_handle), m_parentHandle(data->m_parentHandle), m_x(data->m_x), m_y(data->m_y), m_z(data->m_z), m_so(data->m_so), m_rot(data->m_rot), m_scalex(data->m_scalex), m_scaley(data->m_scaley), m_scale(data->m_scale), m_posPath(data->m_posPath), m_shearx(data->m_shearx), m_sheary(data->m_sheary), m_skeletonDeformation(data->m_skeletonDeformation), m_noScaleZ(data->m_noScaleZ), m_center(data->m_center), m_offset(data->m_offset), m_name(data->m_name), m_isOpened(data->m_isOpened), m_pinnedRangeSet(data->m_pinnedRangeSet->clone())

{

}

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

TStageObjectParams::~TStageObjectParams()

{

	delete m_pinnedRangeSet;

}

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

TStageObjectParams *TStageObjectParams::clone()

{

	return new TStageObjectParams(this);

}

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

// Utility Functions

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

TStageObjectId toStageObjectId(string s)

{

	if (s == "None")

		return TStageObjectId::NoneId;

	else if (s == "Table")

		return TStageObjectId::TableId;

	else if (isInt(s)) {

		TStageObjectId id;

		id.setCode(toInt(s));

		return id;

	} else if (s.length() > 3) {

		if (s.substr(0, 3) == "Col")

			return TStageObjectId::ColumnId(toInt(s.substr(3)) - 1);

		else if (s.substr(0, 3) == "Peg")

			return TStageObjectId::PegbarId(toInt(s.substr(3)) - 1);

		else if (s.length() > 6 && s.substr(0, 6) == "Camera")

			return TStageObjectId::CameraId(toInt(s.substr(6)) - 1);

	}

	return TStageObjectId::NoneId;

}

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

ostream &operator<<(ostream &out, const TStageObjectId &id)

{

	return out << id.toString();

}

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

//    TStageObjectId  implementation

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

TStageObjectId::TStageObjectId() : m_id(NONE << StageObjectTypeShift) {}

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

TStageObjectId::~TStageObjectId() {}

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

bool TStageObjectId::isCamera() const { return m_id >> StageObjectTypeShift == CAMERA; }

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

bool TStageObjectId::isTable() const { return m_id >> StageObjectTypeShift == TABLE; }

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

bool TStageObjectId::isPegbar() const { return m_id >> StageObjectTypeShift == PEGBAR; }

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

bool TStageObjectId::isColumn() const { return m_id >> StageObjectTypeShift == COLUMN; }

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

const TStageObjectId TStageObjectId::NoneId(NONE << StageObjectTypeShift);

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

const TStageObjectId TStageObjectId::TableId(TABLE << StageObjectTypeShift);

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

const TStageObjectId TStageObjectId::CameraId(int index)

{

	assert(0 <= index && index <= StageObjectMaxIndex);

	return TStageObjectId(CAMERA << StageObjectTypeShift | index);

}

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

const TStageObjectId TStageObjectId::PegbarId(int index)

{

	assert(0 <= index && index <= StageObjectMaxIndex);

	return TStageObjectId(PEGBAR << StageObjectTypeShift | index);

}

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

const TStageObjectId TStageObjectId::ColumnId(int index)

{

	assert(0 <= index && index <= StageObjectMaxIndex);

	return TStageObjectId(COLUMN << StageObjectTypeShift | index);

}

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

string TStageObjectId::toString() const

{

	int index = m_id & StageObjectIndexMask;

	string shortName;

	switch (m_id >> StageObjectTypeShift) {

	case NONE:

		shortName = "None";

		break;

	case CAMERA:

		shortName = "Camera" + ::toString(index + 1);

		break;

	case TABLE:

		shortName = "Table";

		break;

	case PEGBAR:

		shortName = "Peg" + ::toString(index + 1);

		break;

	case COLUMN:

		shortName = "Col" + ::toString(index + 1);

		break;

	default:

		shortName = "BadPegbar";

	}

	return shortName;

}

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

int TStageObjectId::getIndex() const

{

	return m_id & StageObjectIndexMask;

}

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

namespace

{ // TStageObject Utility

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

TDoubleKeyframe withFrame(TDoubleKeyframe k, double frame)

{

	k.m_frame = frame;

	return k;

}

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

bool setKeyframe(const TDoubleParamP ¶m, const TDoubleKeyframe &kf,

				 int frame, const double &easeIn, const double &easeOut)

{

	if (!kf.m_isKeyframe)

		return false;

	TDoubleKeyframe kfCopy = kf;

	kfCopy.m_frame = frame;

	if (easeIn >= 0.0)

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

	if (easeOut >= 0.0)

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

	param->setKeyframe(kfCopy);

	return true;

}

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

void setkey(const TDoubleParamP ¶m, int frame)

{

	KeyframeSetter setter(param.getPointer(), -1, false);

	setter.createKeyframe(frame);

}

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

void updateUnit(TDoubleParam *param)

{

	for (int i = 0; i < param->getKeyframeCount(); i++) {

		TDoubleKeyframe k = param->getKeyframe(i);

		k.m_value /= Stage::inch;

		param->setKeyframe(i, k);

	}

}

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

string convertTo4InchCenterUnits(string handle)

{

	// per convenzione un handle del tipo 'a'..'z' utilizza

	// la vecchia convenzione per i centri (4 inch invece di 8)

	if (handle.length() == 1 && 'A' <= handle[0] && handle[0] <= 'Z' && handle[0] != 'B')

		return string(1, handle[0] + 'a' - 'A');

	else

		return handle;

}

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

TPointD updateDagPosition(const TPointD &pos, const VersionNumber &tnzVersion)

{

	if (tnzVersion < VersionNumber(1, 16))

		return TConst::nowhere;

	return pos;

}

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

// Update the passed stage object keyframe and keyframe type specification with

// a new keyframe. Returns true if specifications match, false otherwise.

bool touchEaseAndCompare(const TDoubleKeyframe &kf,

						 TStageObject::Keyframe &stageKf, TDoubleKeyframe::Type &type)

{

	bool initialization = (type == TDoubleKeyframe::None);

	if (initialization)

		type = kf.m_type;

	if (kf.m_type != type ||

		(kf.m_type != TDoubleKeyframe::SpeedInOut &&

		 kf.m_type != TDoubleKeyframe::EaseInOut &&

		 (kf.m_prevType != TDoubleKeyframe::None &&

		  kf.m_prevType != TDoubleKeyframe::SpeedInOut &&

		  kf.m_prevType != TDoubleKeyframe::EaseInOut))) {

		stageKf.m_easeIn = -1.0;

		stageKf.m_easeOut = -1.0;

		return false;

	}

	double easeIn = -kf.m_speedIn.x;

	if (initialization)

		stageKf.m_easeIn = easeIn;

	else if (stageKf.m_easeIn != easeIn)

		stageKf.m_easeIn = -1.0;

	double easeOut = kf.m_speedOut.x;

	if (initialization)

		stageKf.m_easeOut = easeOut;

	else if (stageKf.m_easeOut != easeOut)

		stageKf.m_easeOut = -1.0;

	return true;

}

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

} // namespace

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

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

//    TStageObject::LazyData  implementation

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

TStageObject::LazyData::LazyData()

	: m_time(-1.0)

{

}

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

//    TStageObject  implementation

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

TStageObject::TStageObject(TStageObjectTree *tree, TStageObjectId id)

	: m_tree(tree), m_id(id), m_parent(0), m_name(""), m_isOpened(false), m_spline(0), m_status(XY), m_x(new TDoubleParam()), m_y(new TDoubleParam()), m_z(new TDoubleParam()), m_so(new TDoubleParam()), m_rot(new TDoubleParam()), m_scalex(new TDoubleParam(1.0)), m_scaley(new TDoubleParam(1.0)), m_scale(new TDoubleParam(1.0)), m_posPath(new TDoubleParam()), m_shearx(new TDoubleParam()), m_sheary(new TDoubleParam()), m_center(), m_offset(), m_cycleEnabled(false), m_handle("B"), m_parentHandle("B"), m_dagNodePos(TConst::nowhere), m_camera(0), m_locked(false), m_noScaleZ(0), m_pinnedRangeSet(0), m_ikflag(0), m_groupSelector(-1)

{

	// NOTA: per le unita' di misura controlla anche tooloptions.cpp

	m_x->setName("W_EW");

	m_x->setMeasureName("length.x");

	m_x->addObserver(this);

	m_y->setName("W_NS");

	m_y->setMeasureName("length.y");

	m_y->addObserver(this);

	m_z->setName("W_Z");

	m_z->setMeasureName(id.isCamera() ? "zdepth.cam" : "zdepth");

	m_z->addObserver(this);

	m_so->setName("W_SO");

	m_so->addObserver(this);

	m_rot->setName("W_Rotation");

	m_rot->setMeasureName("angle");

	m_rot->addObserver(this);

	m_scalex->setName("W_ScaleH");

	m_scalex->setMeasureName("scale");

	m_scalex->addObserver(this);

	m_scaley->setName("W_ScaleV");

	m_scaley->setMeasureName("scale");

	m_scaley->addObserver(this);

	m_scale->setName("W_Scale");

	m_scale->setMeasureName("scale");

	m_scale->addObserver(this);

	m_shearx->setName("W_ShearH");

	m_shearx->setMeasureName("shear");

	m_shearx->addObserver(this);

	m_sheary->setName("W_ShearV");

	m_sheary->setMeasureName("shear");

	m_sheary->addObserver(this);

	m_posPath->setName("posPath");

	m_posPath->setMeasureName("percentage2");

	m_posPath->addObserver(this);

	m_tree->setGrammar(m_x);

	m_tree->setGrammar(m_y);

	m_tree->setGrammar(m_z);

	m_tree->setGrammar(m_so);

	m_tree->setGrammar(m_rot);

	m_tree->setGrammar(m_scalex);

	m_tree->setGrammar(m_scaley);

	m_tree->setGrammar(m_scale);

	m_tree->setGrammar(m_shearx);

	m_tree->setGrammar(m_sheary);

	m_tree->setGrammar(m_posPath);

	if (id.isCamera())

		m_camera = new TCamera();

	m_pinnedRangeSet = new TPinnedRangeSet();

}

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

TStageObject::~TStageObject()

{

	if (m_spline) {

		if (m_posPath)

			m_spline->removeParam(m_posPath.getPointer());

		m_spline->release();

	}

	if (m_x)

		m_x->removeObserver(this);

	if (m_y)

		m_y->removeObserver(this);

	if (m_z)

		m_z->removeObserver(this);

	if (m_so)

		m_so->removeObserver(this);

	if (m_rot)

		m_rot->removeObserver(this);

	if (m_scalex)

		m_scalex->removeObserver(this);

	if (m_scaley)

		m_scaley->removeObserver(this);

	if (m_scale)

		m_scale->removeObserver(this);

	if (m_shearx)

		m_shearx->removeObserver(this);

	if (m_sheary)

		m_sheary->removeObserver(this);

	if (m_posPath)

		m_posPath->removeObserver(this);

	if (m_skeletonDeformation) {

		PlasticDeformerStorage::instance()->releaseDeformationData(m_skeletonDeformation.getPointer());

		m_skeletonDeformation->removeObserver(this);

	}

	delete m_camera;

	delete m_pinnedRangeSet;

}

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

const TStageObject::LazyData &TStageObject::lazyData() const

{

	typedef tcg::function<void &)="" &tstageobject::update="" (tstageobject::*)(lazydata="" const,=""> Func;</void>

	return m_lazyData(tcg::bind1st(Func(), *this));

}

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

TStageObject::LazyData &TStageObject::lazyData()

{

	return const_cast<lazydata &="">(static_cast<const &="" tstageobject="">(*this).lazyData());</const></lazydata>

}

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

void TStageObject::update(LazyData &ld) const

{

	if (ld.m_time >= 0.0)

		invalidate(ld);

	updateKeyframes(ld);

}

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

void TStageObject::onChange(const class TParamChange &c)

{

	// Rationale: Since a stage object holds many parameters (or par references),

	// it may receive multiple notifications at the same time - but it should

	// actually refresh its data only ONCE for 'em all.

	// Even worse, the stage object may be notified for EACH touched key of just

	// one of its parameters. This means this function gets called A LOT.

	// Thus, we're just SCHEDULING for a data refresh. The actual refresh happens

	// whenever the scheduled datas are accessed.

	if (c.m_keyframeChanged)

		m_lazyData.invalidate(); // Both invalidate placement AND keyframes

	else

		invalidate(); // Invalidate placement only

}

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

TStageObjectId TStageObject::getId() const

{

	return m_id;

}

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

double TStageObject::paramsTime(double t) const

{

	const KeyframeMap &keyframes = lazyData().m_keyframes;

	if (m_cycleEnabled && keyframes.size() > 1) {

		int firstT = keyframes.begin()->first;

		if (t <= firstT)

			return t;

		int lastT = keyframes.rbegin()->first;

		int tRange = lastT - firstT + 1;

		assert(tRange > 0);

		int it = tfloor(t);

		double ft = t - it;

		return firstT + ((it - firstT) % tRange) + ft;

	} else

		return t;

}

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

void TStageObject::setName(const std::string &name)

{

	m_name = (name == m_id.toString()) ? std::string() : name;

}

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

string TStageObject::getName() const

{

	if (m_name != "")

		return m_name;

	if (!m_id.isColumn())

		return m_id.toString();

	wstring s = L"Col" + toWideString(m_id.getIndex() + 1);

	return toString(s);

}

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

string TStageObject::getFullName() const

{

	string name = getName();

	if (m_id.isColumn()) {

		if (name.find("Col") == 0 &&

			name.length() > 3 &&

			name.find_first_not_of("0123456789", 3) == string::npos)

			return name;

		else

			return name + " (" + toString(m_id.getIndex() + 1) + ")";

	} else

		return name;

}

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

void TStageObject::setParent(const TStageObjectId &parentId)

{

	assert(m_tree);

	TStageObject *newParent = 0;

	if (parentId != TStageObjectId::NoneId) {

		newParent = m_tree->getStageObject(parentId);

		assert(newParent);

		// cerco di evitare i cicli

		TStageObject *p = newParent;

		while (p->m_parent) {

			if (p->m_parent->getId() == getId())

				return;

			p = p->m_parent;

		}

	} else {

		if (!m_id.isCamera() && !m_id.isTable()) {

			newParent = m_tree->getStageObject(TStageObjectId::TableId);

			assert(newParent);

		}

	}

	if (m_parent)

		m_parent->m_children.remove(this);

	m_parent = newParent;

	if (m_parent)

		m_parent->m_children.insert(m_parent->m_children.end(), this);

	invalidate();

#ifndef NDEBUG

	if (m_id.isCamera()) {

	} else if (m_id.isTable()) {

		assert(m_parent == 0);

	} else if (m_id.isColumn()) {

		assert(m_parent &&

			   (m_parent->m_id.isTable() ||

				m_parent->m_id.isColumn() ||

				m_parent->m_id.isPegbar() ||

				m_parent->m_id.isCamera()));

	} else if (m_id.isPegbar()) {

		assert(m_parent &&

			   (m_parent->m_id.isTable() ||

				m_parent->m_id.isCamera() ||

				m_parent->m_id.isPegbar()));

	} else {

		assert(0);

	}

#endif

}

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

void TStageObject::detachFromParent()

{

	if (m_parent)

		m_parent->m_children.remove(this);

	m_parent = 0;

	invalidate();

}

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

void TStageObject::attachChildrenToParent(const TStageObjectId &parentId)

{

	while (!m_children.empty()) {

		TStageObject *son = *m_children.begin();

		if (son)

			son->setParent(parentId);

	}

}

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

TStageObjectId TStageObject::getParent() const

{

	return m_parent ? m_parent->m_id : TStageObjectId();

}

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

bool TStageObject::isAncestor(TStageObject *stageObject) const

{

	if (!stageObject)

		return false;

	if (stageObject == (TStageObject *)m_parent)

		return true;

	else if (m_parent == 0)

		return false;

	else

		return m_parent->isAncestor(stageObject);

}

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

TStageObjectSpline *TStageObject::getSpline() const

{

	return m_spline;

}

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

void TStageObject::doSetSpline(TStageObjectSpline *spline)

{

	TDoubleParam *param = m_posPath.getPointer();

	bool uppkEnabled = isUppkEnabled();

	if (!spline) {

		if (uppkEnabled && m_spline)

			m_spline->removeParam(param);

		if (m_spline)

			m_spline->release();

		m_spline = 0;

		enablePath(false);

	} else {

		if (m_spline != spline) {

			if (m_spline && uppkEnabled)

				m_spline->removeParam(param);

			if (m_spline)

				m_spline->release();

			m_spline = spline;

			m_spline->addRef();

			if (m_spline && uppkEnabled)

				m_spline->addParam(param);

		}

		if (!isPathEnabled())

			enablePath(true);

	}

}

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

void TStageObject::setSpline(TStageObjectSpline *spline)

{

	doSetSpline(spline);

	TNotifier::instance()->notify(TXsheetChange());

	TNotifier::instance()->notify(TStageChange());

	invalidate();

}

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

void TStageObject::setStatus(Status status)

{

	if (m_status == status)

		return;

	bool oldPathEnabled = isPathEnabled();

	bool oldUppkEnabled = isUppkEnabled();

	m_status = status;

	bool pathEnabled = isPathEnabled();

	bool uppkEnabled = isUppkEnabled();

	if (pathEnabled) {

		if (!m_spline)

			doSetSpline(m_tree->createSpline());

		else if (oldUppkEnabled != uppkEnabled) {

			TDoubleParam *param = getParam(T_Path);

			if (uppkEnabled)

				m_spline->addParam(param);

			else

				m_spline->removeParam(param);

		}

	} else {

		doSetSpline(0);

	}

	invalidate();

}

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

void TStageObject::enableAim(bool enabled)

{

	setStatus((Status)((m_status & ~STATUS_MASK) | (enabled ? PATH_AIM : PATH)));

}

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

void TStageObject::enablePath(bool enabled)

{

	if (isPathEnabled() != enabled)

		setStatus(enabled ? PATH : XY);

}

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

void TStageObject::enableUppk(bool enabled)

{

	assert(isPathEnabled());

	setStatus((Status)((m_status & ~UPPK_MASK) | (enabled ? UPPK_MASK : 0)));

}

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

void TStageObject::setCenter(double frame, const TPointD ¢er)

{

	TPointD c = center - getHandlePos(m_handle, (int)frame);

	TAffine aff = computeLocalPlacement(frame);

	TPointD delta = aff * c - aff * m_center;

	m_center = c;

	m_offset += delta;

	invalidate();

}

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

TPointD TStageObject::getCenter(double frame) const

{

	return m_center + getHandlePos(m_handle, (int)frame);

}

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

TPointD TStageObject::getOffset() const

{

	return m_offset;

}

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

void TStageObject::setOffset(const TPointD &off)

{

	m_offset = off;

	invalidate();

}

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

void TStageObject::getCenterAndOffset(TPointD ¢er, TPointD &offset) const

{

	center = m_center;

	offset = m_offset;

}

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

void TStageObject::setCenterAndOffset(const TPointD ¢er, const TPointD &offset)

{

	m_center = center;

	m_offset = offset;

	invalidate();

}

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

void TStageObject::setHandle(const std::string &s)

{

	m_handle = s;

	if (!s.empty() && s[0] == 'H')

		m_offset = m_center = TPointD();

	invalidate();

}

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

void TStageObject::setParentHandle(const std::string &s)

{

	m_parentHandle = s;

	invalidate();

}

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

TPointD TStageObject::getHandlePos(string handle, int row) const

{

	double unit = 8;

	if (handle == "")

		return TPointD();

	else if (handle.length() > 1 && handle[0] == 'H')

		return m_tree->getHandlePos(m_id, handle, row);

	else if (handle.length() == 1 && 'A' <= handle[0] && handle[0] <= 'Z')

		return TPointD(unit * (handle[0] - 'B'), 0);

	else if (handle.length() == 1 && 'a' <= handle[0] && handle[0] <= 'z')

		return TPointD(0.5 * unit * (handle[0] - 'b'), 0);

	else

		return TPointD(0, 0);

}

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

bool TStageObject::isKeyframe(int frame) const

{

	const KeyframeMap &keyframes = lazyData().m_keyframes;

	return keyframes.find(frame) != keyframes.end();

}

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

bool TStageObject::is52FullKeyframe(int frame) const

{

	return m_rot->isKeyframe(frame) &&

		   m_x->isKeyframe(frame) &&

		   m_y->isKeyframe(frame) &&

		   m_z->isKeyframe(frame) &&

		   m_posPath->isKeyframe(frame) &&

		   m_scalex->isKeyframe(frame) &&

		   m_scaley->isKeyframe(frame) &&

		   m_shearx->isKeyframe(frame) &&

		   m_sheary->isKeyframe(frame);

}