tahoma2d/toonz/sources/toonzlib/skeleton.cpp

#include "toonz/skeleton.h"
#include "toonz/tstageobject.h"
#include "toonz/tpinnedrangeset.h"
#include "toonz/tstageobjectkeyframe.h"
#include "toonz/txsheet.h"
#include "toonz/stage.h"

namespace
{

TStageObjectId getAncestor(TXsheet *xsh, TStageObjectId id)
{
	assert(id.isColumn());
	TStageObjectId parentId;
	while (parentId = xsh->getStageObjectParent(id), parentId.isColumn())
		id = parentId;
	return id;
}

} // namespace

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

int Skeleton::Bone::getColumnIndex() const
{
	return m_stageObject->getId().getIndex();
}

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

void Skeleton::Bone::setParent(Bone *parent)
{
	if (m_parent != parent) {
		m_parent = parent;
		parent->m_children.push_back(this);
	}
}

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

Skeleton::Skeleton()
	: m_rootBone(0)
{
}

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

Skeleton::~Skeleton()
{
	clearPointerContainer(m_bones);
}

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

void Skeleton::clear()
{
	clearPointerContainer(m_bones);
	m_rootBone = 0;
}

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

void Skeleton::build(TXsheet *xsh, int row, int col, const std::set<int> &tempPinnedColumns)
{
	// clear
	m_rootBone = 0;
	clearPointerContainer(m_bones);

	// antenato (colonna) della colonna corrente
	TStageObjectId ancestorId = getAncestor(xsh, TStageObjectId::ColumnId(col));

	// costruisco le "ossa"
	std::map<TStageObjectId, Bone *> boneTable;
	int columnCount = xsh->getColumnCount();
	int pinnedCount = 0;
	for (int i = 0; i < columnCount; i++) {
		TStageObjectId columnId(TStageObjectId::ColumnId(i));
		if (getAncestor(xsh, columnId) != ancestorId)
			continue;

		TAffine aff = xsh->getPlacement(columnId, row);
		TPointD center = Stage::inch * xsh->getCenter(columnId, row);
		TPointD p = aff * center;
		TStageObject *obj = xsh->getStageObject(columnId);
		Bone *bone = new Bone(obj, p);
		boneTable[columnId] = bone;
		m_bones.push_back(bone);
		if (columnId == ancestorId)
			m_rootBone = bone;

		if (obj->getPinnedRangeSet()->isPinned(row)) {
			pinnedCount++;
			bone->setPinnedStatus(Bone::PINNED);
		} else if (tempPinnedColumns.count(i) > 0)
			bone->setPinnedStatus(Bone::TEMP_PINNED);
	}

	// if no bone is pinned then the root is considered pinned
	if (pinnedCount == 0 && m_rootBone)
		m_rootBone->setPinnedStatus(Bone::PINNED);

	// The skeleton could possibly be empty
	if (boneTable.empty()) {
		assert(!m_rootBone);
		return;
	}

	// assign parents
	std::map<TStageObjectId, Bone *>::iterator it, sit;
	for (it = boneTable.begin(); it != boneTable.end(); ++it) {
		sit = boneTable.find(xsh->getStageObjectParent(it->first));
		if (sit != boneTable.end())
			it->second->setParent(sit->second);
	}

	// select the "active chain", i.e. the starting bone (columnIndex=col) and the ancestors
	it = boneTable.find(TStageObjectId::ColumnId(col));
	if (it != boneTable.end()) {
		Bone *bone = it->second;
		while (bone) {
			bone->select();
			bone = bone->getParent();
		}
	}
}

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

Skeleton::Bone *Skeleton::getBone(int index) const
{
	assert(0 <= index && index < (int)m_bones.size());
	return m_bones[index];
}

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

Skeleton::Bone *Skeleton::getBoneByColumnIndex(int columnIndex) const
{
	for (int i = 0; i < (int)m_bones.size(); i++)
		if (m_bones[i]->getColumnIndex() == columnIndex)
			return m_bones[i];
	return 0;
}

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

bool Skeleton::isIKEnabled() const
{
	return m_rootBone && m_rootBone->getStageObject()->getStatus() == TStageObject::IK;
}

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

bool Skeleton::hasPinnedRanges() const
{
	for (int i = 0; i < getBoneCount(); i++) {
		TStageObject *obj = getBone(i)->getStageObject();
		if (obj->getPinnedRangeSet()->getRangeCount() > 0)
			return true;
	}
	return false;
}

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

void Skeleton::clearAllPinnedRanges()
{
	for (int i = 0; i < getBoneCount(); i++) {
		TStageObject *obj = getBone(i)->getStageObject();
		obj->getPinnedRangeSet()->removeAllRanges();
		obj->invalidate();
	}
}