int CRps::SetMotion( MODELBOUND srcmb, TSELEM* tsptr, int cookie, double setframe )
{
int frameno = 0;
if( cookie < 0 ){
return 0;
}
int skelno;
for( skelno = 0; skelno < SKEL_MAX; skelno++ ){
CTraQ* curtraq = (m_traq + 2 * SKEL_MAX + skelno);
int boneno;
boneno = (tsptr + skelno)->jointno;
CBone* curbone = m_model->m_bonelist[ boneno ];
_ASSERT( curbone );
if( curtraq->m_outputflag == 1 ){
CQuaternion curq;
curq = curtraq->m_finalq;
/***
CMotionPoint* mpptr;
mpptr = m_armp[ skelno ];
while( mpptr && !( (mpptr->m_frame >= (setframe - 0.1)) && (mpptr->m_frame <= (setframe + 0.1)) ) ){
mpptr = mpptr->m_next;
if( mpptr->m_frame > (setframe + 0.45) ){
if( mpptr->m_prev ){
mpptr = mpptr->m_prev;
}
break;
}
}
m_armp[ skelno ] = mpptr;
***/
CMotionPoint* mpptr = 0;
CMotionPoint* nextptr = 0;
int existflag = 0;
curbone->GetBefNextMP( cookie, setframe, &mpptr, &nextptr, &existflag );
_ASSERT( existflag );
if( mpptr ){
if( skelno == SKEL_TOPOFJOINT ){
D3DXVECTOR3 settra;
settra = curtraq->m_finaltra;
float modelh = srcmb.max.y - srcmb.min.y;
float trascale = modelh / 3000.0f;
mpptr->m_tra = settra * trascale;
}
CQuaternion setq = curtraq->m_finalq * curbone->m_kinectq;
mpptr->SetQ( &curbone->m_axisq, setq );
}
}
}
m_model->SetMotionFrame( setframe );
return 0;
}
CStaticMesh_DX8::CStaticMesh_DX8(CEntity_StaticMesh* in_pMesh) :
m_pStaticMesh(in_pMesh)
{
assert(m_pStaticMesh);
// construct shadow for skeleton
const std::vector< CBone* >& rSrcBones = m_pStaticMesh->GetSkeleton().GetBoneIDs();
m_Skeleton.m_BoneIDs.resize( rSrcBones.size() );
for( size_t i=0; i<rSrcBones.size(); ++i )
m_Skeleton.m_BoneIDs[i] = NULL;
CBone* pSrcRootBone = m_pStaticMesh->GetSkeleton().GetRootBone();
if(pSrcRootBone) {
m_Skeleton.m_pRootBone = CreateBoneShadowRecurse( pSrcRootBone, NULL );
assert( !rSrcBones.empty() );
for( size_t i=0; i<rSrcBones.size(); ++i ) {
assert( m_Skeleton.m_BoneIDs[i] != NULL );
if( m_Skeleton.m_BoneIDs[i]->m_BoneID == pSrcRootBone->GetID() ) {
m_Skeleton.m_pRootBone = m_Skeleton.m_BoneIDs[i];
}
}
}
}
bool CBone::RemoveChild(CSceneNode& Child)
{
if( CSceneNode::RemoveChild(Child) )
{
CBone* pBone = dynamic_cast<CBone*>(&Child);
if(pBone)
{
pBone->m_bIsBoneParent = false;
CBone* pTemp = this;
while(pTemp->m_pNext)
{
if(pTemp->m_pNext == pBone)
break;
pTemp = pTemp->m_pNext;
}
CBone& Tail = pBone->__GetTreeTail();
pTemp->m_pNext = Tail.m_pNext;
Tail.m_pNext = ALCHEMY_NULL;
}
return true;
}
return false;
}
bool CSkeleton::ReadXML( TiXmlNode* poParent )
{
if( !poParent )
return false;
switch ( poParent->Type() )
{
case TiXmlNode::DOCUMENT:
SKELETON_LOG( "XML: Document" );
break;
case TiXmlNode::ELEMENT:
{
const char *pcName = poParent->Value();
if( !strcmp( pcName, "bone" ) )
{
SKELETON_LOG( "\nbone:\n\n" );
CBone * poBone = new CBone;
poBone->ReadXMLAttrib( poParent->ToElement() );
poBone->m_uiIndex = m_uiBone;
m_oArrBone.Append( poBone );
++m_uiBone;
}
/*
SKELETON_LOG( "Element [%s]", poParent->Value() );
switch(num)
{
case 0: SKELETON_LOG( " (No attributes)"); break;
case 1: SKELETON_LOG( "1 attribute"); break;
default: SKELETON_LOG( "%d attributes", num); break;
}
*/
}
break;
case TiXmlNode::COMMENT:
SKELETON_LOG( "XML: Comment: [%s]", poParent->Value());
break;
case TiXmlNode::UNKNOWN:
SKELETON_LOG( "XML: Unknown" );
break;
case TiXmlNode::TEXT:
SKELETON_LOG( "XML: Text: [%s]", poParent->ToText()->Value() );
break;
case TiXmlNode::DECLARATION:
SKELETON_LOG( "XML: Declaration" );
break;
default:
break;
}
SKELETON_LOG( "\n" );
for( TiXmlNode * poChild = poParent->FirstChild(); poChild != 0; poChild = poChild->NextSibling() )
{
ReadXML( poChild );
}
return true;
}
CSkeleton::TVec CSkeleton::GetBonePos( const char *pcName )
{
TVec oPos;
CBone * poBone = GetBone( pcName );
if( poBone )
{
oPos = poBone->GetPos();
}
return oPos;
}
CSkeleton::TVec CSkeleton::GetBoneDirNormalized( const char *pcName )
{
TVec oDirNormalized;
CBone * poBone = GetBone( pcName );
if( poBone )
{
oDirNormalized = poBone->GetDirNormalized();
}
return oDirNormalized;
}
CSkeleton::TVec CSkeleton::GetBoneDir( const char *pcName )
{
TVec oDir;
CBone * poBone = GetBone( pcName );
if( poBone )
{
oDir = poBone->GetDir();
}
return oDir;
}
//------------------------------------------------------------------------------------------
void CSkeleton::ComputeBonesDefaultInvMat()
{
for( u32 i=0; i<m_bones.Size(); i++ )
{
CBone* bone = m_bones[i];
m4x4 defaultModelTM = i4x4;
bone->GetDefaultModelTM( defaultModelTM );
InvMat( defaultModelTM, bone->m_invDefaultModelTM );
}
}
DumpChildren(const std::vector<CBone*>& vec, int j =0)
{
for (int i = 0 ; i < vec.size() ; i ++ )
{
CBone* next = vec[i];
for (int k = 0 ; k < j ; k ++ ) CLog::Print(" ");
CLog::Println(next->GetName().c_str());
DumpChildren(next->GetChildren(),j+1);
}
}
bool CEditableObject::LoadBoneData(IReader& F)
{
BoneVec load_bones;
int count=0;
IReader* R;
while(0!=(R=F.open_chunk(count++)))
{
CBone* nBone = xr_new<CBone>();
load_bones.push_back(nBone);
nBone->LoadData(*R);
Msg("loaded bone [%s]", nBone->Name().c_str());
}
bool bRes = true;
// load bones
if (!load_bones.empty()){
for (BoneIt b_it=m_Bones.begin(); b_it!=m_Bones.end(); b_it++){
CBone* B = *b_it;
BoneIt n_it = std::find_if(load_bones.begin(),load_bones.end(),fBoneNameEQ(B->Name()));
if (n_it!=load_bones.end())
{
B->CopyData (*n_it);
}else{
ELog.Msg (mtError,"Can't find bone: '%s'.",*(*b_it)->Name());
bRes = false;
// break;
}
}
for (BoneIt n_it=load_bones.begin(); n_it!=load_bones.end(); n_it++)
xr_delete(*n_it);
load_bones.clear();
}else{
ELog.Msg (mtError,"Empty bone list.");
bRes = false;
}
// load bone part
if (F.find_chunk(EOBJ_CHUNK_BONEPARTS2)){
shared_str buf;
m_BoneParts.resize(F.r_u32());
for (BPIt bp_it=m_BoneParts.begin(); bp_it!=m_BoneParts.end(); bp_it++){
F.r_stringZ (buf); bp_it->alias=buf;
bp_it->bones.resize (F.r_u32());
for (RStringVecIt s_it=bp_it->bones.begin(); s_it!=bp_it->bones.end(); s_it++)
F.r_stringZ (*s_it);
}
if (!m_BoneParts.empty()&&!VerifyBoneParts())
ELog.Msg (mtError,"Invalid bone parts. Found missing or duplicate bone.");
}else{
ELog.Msg (mtError,"Can't load bone parts. Invalid version.");
}
return bRes;
}
void CBone::RegisterAnimationController(CAnimationController& AnimationController)
{
CBone* pBone = this, * pEnd = __GetTreeTail().m_pNext;
while(pBone != pEnd)
{
AnimationController.RegisterAnimationOutput(pBone->GetName(), pBone->m_LocalMatrix);
pBone = pBone->m_pNext;
}
m_bIsRegisterAnimationController = true;
}
//----------------------------------------------------------------------------
// Skeleton functions
//----------------------------------------------------------------------------
bool CEditableObject::ImportMAXSkeleton(CExporter* E)
{
bool bResult = true;
CEditableMesh* MESH = xr_new<CEditableMesh>(this);
m_Meshes.push_back(MESH);
// import mesh
if (!MESH->Convert(E)) return FALSE;
// BONES
m_Bones.reserve(E->m_Bones.size());
for (int B=0; B!=E->m_Bones.size(); B++){
m_Bones.push_back(xr_new<CBone>());
CBone* BONE = m_Bones.back();
CBoneDef* bone = E->m_Bones[B];
CBoneDef* parent_bone = bone->parent;
Fvector offset,rotate;
float length= 0.1f;
Fmatrix m;
if (parent_bone) m.mul(parent_bone->matOffset,bone->matInit);
else m.set(bone->matInit);
m.getXYZi (rotate);
offset.set (m.c);
BONE->SetWMap (bone->name.c_str());
BONE->SetName (bone->name.c_str());
BONE->SetParentName (Helper::ConvertSpace(string(bone->pBone->GetParentNode()->GetName())).c_str());
BONE->SetRestParams (length,offset,rotate);
}
// DEFAULT BONE PART
m_BoneParts.push_back(SBonePart());
SBonePart& BP = m_BoneParts.back();
BP.alias = "default";
for (int b_i=0; b_i<(int)m_Bones.size(); b_i++)
BP.bones.push_back(Bones()[b_i]->Name());
m_objectFlags.set(CEditableObject::eoDynamic,TRUE);
if ((0==GetVertexCount())||(0==GetFaceCount())){
bResult = false;
}else{
ELog.Msg(mtInformation,"Model '%s' contains: %d points, %d faces, %d bones", E->m_MeshNode->GetName(), GetVertexCount(), GetFaceCount(), Bones().size());
}
return bResult;
}
int CRps::InitArMp( TSELEM* tsptr, int motid, double frameno )
{
int skelno, boneno;
for( skelno = 0; skelno < SKEL_MAX; skelno++ ){
boneno = (tsptr + skelno)->jointno;
_ASSERT( boneno >= 0 );
CBone* curbone = m_model->m_bonelist[ boneno ];
CMotionPoint* mpptr = 0;
CMotionPoint* nextptr = 0;
int existflag = 0;
curbone->GetBefNextMP( motid, frameno, &mpptr, &nextptr, &existflag );
_ASSERT( existflag && mpptr );
m_armp[ skelno ] = mpptr;
}
return 0;
}
void CSMotion::SortBonesBySkeleton(BoneVec& bones)
{
BoneMotionVec new_bone_mots;
for (BoneIt b_it = bones.begin(); b_it != bones.end(); ++b_it)
{
st_BoneMotion* BM = FindBoneMotion((*b_it)->Name());
if (!BM)
{
CBone* B = *(b_it);
bone_mots.push_back(st_BoneMotion());
st_BoneMotion& bm0 = bone_mots[0];
st_BoneMotion& bm = bone_mots.back();
bm.SetName(B->Name().c_str());
bm.m_Flags.assign(bm0.m_Flags);
for (int ch = 0; ch < ctMaxChannel; ++ch)
{
bm.envs[ch] = xr_new<CEnvelope>();
//. bm.envs[ch]->Load_2(F);
}
bm.envs[ctPositionX]->InsertKey(0.0f, B->_Offset().x);
bm.envs[ctPositionY]->InsertKey(0.0f, B->_Offset().y);
bm.envs[ctPositionZ]->InsertKey(0.0f, B->_Offset().z);
bm.envs[ctRotationH]->InsertKey(0.0f, B->_Rotate().x);
bm.envs[ctRotationP]->InsertKey(0.0f, B->_Rotate().y);
bm.envs[ctRotationB]->InsertKey(0.0f, B->_Rotate().z);
BM = &bm;
};
new_bone_mots.push_back(*BM);
}
bone_mots.clear();
bone_mots = new_bone_mots;
}
bool CBone::AddChild(CSceneNode& Child)
{
if( CSceneNode::AddChild(Child) )
{
CBone* pBone = dynamic_cast<CBone*>(&Child);
if(pBone)
{
pBone->m_bIsBoneParent = true;
CBone& Temp = pBone->__GetTreeTail();
Temp.m_pNext = m_pNext;
m_pNext = pBone;
}
return true;
}
return false;
}
int CUndoMotion::RollBackMotion( CModel* pmodel, int* curboneno, int* curbaseno )
{
if( m_validflag != 1 ){
_ASSERT( 0 );
return 1;
}
int setmotid = m_savemotinfo.motid;
MOTINFO* chkmotinfo = pmodel->m_motinfo[ setmotid ];
if( !chkmotinfo ){
_ASSERT( 0 );
return 1;
}
/////// destroy
map<int, CBone*>::iterator itrbone;
for( itrbone = pmodel->m_bonelist.begin(); itrbone != pmodel->m_bonelist.end(); itrbone++ ){
CBone* curbone = itrbone->second;
_ASSERT( curbone );
curbone->DestroyMotionKey( setmotid );
}
map<int, CMQOObject*>::iterator itrbase;
for( itrbase = pmodel->m_mbaseobject.begin(); itrbase != pmodel->m_mbaseobject.end(); itrbase++ ){
CMQOObject* curbase = itrbase->second;
_ASSERT( curbase );
curbase->DestroyMorphKey( setmotid );
}
///////// set
for( itrbone = pmodel->m_bonelist.begin(); itrbone != pmodel->m_bonelist.end(); itrbone++ ){
CBone* curbone = itrbone->second;
_ASSERT( curbone );
CMotionPoint* firstmp = m_bone2mp[ curbone ];
if( firstmp ){
CMotionPoint* undofirstmp = new CMotionPoint();
if( !undofirstmp ){
_ASSERT( 0 );
return 1;
}
undofirstmp->CopyMotion( firstmp );
CMotionPoint* mpptr = firstmp->m_next;
CMotionPoint* befundomp = undofirstmp;
while( mpptr ){
CMotionPoint* newundomp = new CMotionPoint();
if( !newundomp ){
_ASSERT( 0 );
return 1;
}
newundomp->CopyMotion( mpptr );
befundomp->AddToNext( newundomp );
befundomp = newundomp;
mpptr = mpptr->m_next;
}
curbone->m_motionkey[ setmotid ] = undofirstmp;
}
}
for( itrbase = pmodel->m_mbaseobject.begin(); itrbase != pmodel->m_mbaseobject.end(); itrbase++ ){
CMQOObject* curbase = itrbase->second;
_ASSERT( curbase );
CMorphKey* firstmk = m_base2mk[ curbase ];
if( firstmk ){
CMorphKey* undofirstmk = new CMorphKey( curbase );
if( !undofirstmk ){
_ASSERT( 0 );
return 1;
}
undofirstmk->CopyMotion( firstmk );
CMorphKey* mkptr = firstmk->m_next;
CMorphKey* befundomk = undofirstmk;
while( mkptr ){
CMorphKey* newundomk = new CMorphKey( curbase );
if( !newundomk ){
_ASSERT( 0 );
return 1;
}
newundomk->CopyMotion( mkptr );
befundomk->AddToNext( newundomk );
befundomk = newundomk;
mkptr = mkptr->m_next;
}
curbase->m_morphkey[ setmotid ] = undofirstmk;
}
}
MoveMemory( chkmotinfo, &m_savemotinfo, sizeof( MOTINFO ) );
pmodel->m_curmotinfo = chkmotinfo;
*curboneno = m_curboneno;
*curbaseno = m_curbaseno;
return 0;
}
