/cygdrive/d/src/svn/vrut/trunk/modules/trackingmanipulator/ttable.cpp

Go to the documentation of this file.

#include "ttable.h"

using namespace VRUT;

Condition::Condition(int pressed, int released, float ctrl1, float ctrl2)
{
       Reset(pressed, released, ctrl1, ctrl2);
}
Condition::~Condition()
{}
bool Condition::Evaluate(int buttons, float ctr1, float ctr2)
{
       if (((buttons & pressedButtonsMask) == pressedButtonsMask) && (releasedButtonsMask & buttons) == 0)
       {
              // buttons restrictions are satisfied
              if (((control1 < 0) &&  (ctr1 > control1)) || ((control1 >= 0) && (ctr1 < control1)))
              {
                     // control1 did not reched treshold
                     return false;
              }
              if (((control2 < 0) &&  (ctr2 > control2)) || ((control2 >= 0) && (ctr2 < control2)))
              {
                     return false;
              }
              return true; // all restrictions are satisfied
       }
       else
       {
              // buttons not satisfied
              return false;
       }
}
void Condition::Reset(int pressed, int released, float ctrl1, float ctrl2)
{
       pressedButtonsMask = pressed;
       releasedButtonsMask = released;
       control1 = ctrl1;
       control2 = ctrl2;
}
int Condition::PressedMask(){return pressedButtonsMask;}
int Condition::ReleasedMask(){return releasedButtonsMask;}
float Condition::Control1(){return control1;}
float Condition::Control2(){return control2;}

TTableEntry::TTableEntry(int BodyID, Body::BodyType type, int IDscene, int IDsceneNode, Condition condition, TTableEntry::TransformMode mod, float scale)
{
       this->bodyType = type;
       this->idBody = BodyID;
       this->idScene = IDscene;
       this->idSceneNode= IDsceneNode;
       transformCondition = condition;
       this->scale = scale;
       mode = mod;
       changed = false;
}
TTableEntry::~TTableEntry()
{
}
void TTableEntry::SetScale(float scale)
{
       changed = true;
       this->scale = scale;
}
void TTableEntry::SetTransformMode(TTableEntry::TransformMode mod)
{
       changed = true;
       mode = mod;
}
void TTableEntry::SetSceneNode(int scene, int node)
{
       changed = true;
       idScene = scene;
       idSceneNode = node;
}
void TTableEntry::SetCondition(Condition condition)
{
       changed = true;
       transformCondition = condition;
}
float TTableEntry::GetScale()
{
       return scale;
}
TTableEntry::TransformMode TTableEntry::GetTransformationMode()
{
       return mode;
}

int TTableEntry::GetSceneID()
{
       return idScene;
}
int TTableEntry::GetSceneNodeID()
{
       return idSceneNode;
}
void TTableEntry::GetSceneNode(int &scene, int &node)
{
       scene = idScene;
       node = idSceneNode;
}
Condition TTableEntry::GetCondition()
{
       return transformCondition;
}
int TTableEntry::GetBodyID()
{
       return idBody;
}
Body::BodyType TTableEntry::GetBodyType()
{
       return bodyType;
}
bool TTableEntry::EvaluateCondition(int buttons, float c1, float c2)
{
       return this->transformCondition.Evaluate(buttons, c1, c2);
}
void TTableEntry::relativeMatrix(MATRIX & prev, MATRIX & curr)
{
       float cy2 = cosf(asinf(curr._m13));
       float cy1 = cosf(asinf(prev._m13)); // cosinus of Ry angle
       float sinX = ((curr._m23 / (-1 * cy2)) * (prev._m33 / cy1)) - ((curr._m33 / cy2) * (prev._m23 / (-1 * cy1)));
       float cosX = (curr._m33 / cy2)*(prev._m33 / cy1) + (curr._m23 / (-1 * cy2)) * (prev._m23 / (-1 * cy1));
       float sinY = (curr._m13 * cy1) - (cy2 * prev._m13);
       float cosY = (cy2 * cy1) + (curr._m13 * prev._m13);
       float sinZ = ((curr._m12 / (-1 * cy2)) * (prev._m11 / cy1)) - ((curr._m11 / cy2) * (prev._m12 / (-1 * cy1)));
       float cosZ = ((curr._m11 / cy2) * (prev._m11 / cy1)) + ((curr._m12 / (-1 * cy2)) * (prev._m12 / (-1 * cy1)));
       // rebuild rotation matrix
       //row1
       curr._m11 = cosZ * cosY;
       curr._m12 = (-1 * sinZ) * cosY;
       curr._m13 = sinY;
       //row2
       curr._m21 = (sinZ * cosX) + (cosZ * sinY * sinX);
       curr._m22 = (cosZ * cosX) - (sinZ * sinY * sinX);
       curr._m23 = (-1 * cosY) * sinX;
       //row3
       curr._m31 = (sinZ * sinX) - (cosZ * sinY * cosX);
       curr._m32 = (cosZ * sinX) + (sinZ * sinY * cosX);
       curr._m33 = cosY * cosX;
       // translation
       curr._m41 -= prev._m41;     curr._m42 -= prev._m42;     curr._m43 -= prev._m43;
}
void TTableEntry::generateEvent(MATRIX bodyMatrix,int buttons, float c1, float c2, VRUT::SceneModule * module)
{
// testovaci

       
       //
       if (changed && EvaluateCondition(buttons, c1,c2))
       {
              MATRIX tempMatrix = bodyMatrix;
              MATRIX scaleMatrix; scaleMatrix._m11 = scaleMatrix._m22 = scaleMatrix._m33 = scale;
              scaleMatrix._m44=1;
              Scene * scene = module->GetSceneMgr()->GetScene(this->idScene);
              const SceneNode * node =scene->GetNode(this->idSceneNode);
              scene->UpdateTransformation(this->idSceneNode);
              switch(mode)
              {
              case TRANSFORM_RELATIVE:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            MATRIX transform = this->transformMatrix(&tempMatrix, curr);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_TRANSLATION:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            tempMatrix._m11 = tempMatrix._m22 = tempMatrix._m33 = tempMatrix._m44 = 1;
                            tempMatrix._m12 = tempMatrix._m13 = tempMatrix._m14 = tempMatrix._m21 = tempMatrix._m23 = tempMatrix._m24 =     tempMatrix._m31 = tempMatrix._m32 = tempMatrix._m34 = 0;
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,tempMatrix);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_ABSOLUTE:
                     {
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            wxCommandEvent evt = VRUT::Event::GET_EVT_SCENE_NODE_TRANSFORM_SET(this->idScene, this->idSceneNode, tempMatrix);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_ROTATION:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            tempMatrix = tempMatrix.ExtractRotation();
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            MATRIX transform = this->transformMatrix(&tempMatrix, curr);
                            wxCommandEvent evt = VRUT::Event::GET_EVT_SCENE_NODE_TRANSFORM(this->idScene, this->idSceneNode, transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_USE_RELATIVE:
                     {
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            MATRIX transform = this->transformMatrix(&tempMatrix, curr);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_USE_ROTATION:
                     {
                            tempMatrix = tempMatrix.ExtractRotation();
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            MATRIX transform = this->transformMatrix(&tempMatrix, curr);
                            wxCommandEvent evt = VRUT::Event::GET_EVT_SCENE_NODE_TRANSFORM(this->idScene, this->idSceneNode, transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case TRANSFORM_USE_TRANSLATION:
                     {
                            tempMatrix._m11 = tempMatrix._m22 = tempMatrix._m33 = tempMatrix._m44 = 1;
                            tempMatrix._m12 = tempMatrix._m13 = tempMatrix._m14 = tempMatrix._m21 = tempMatrix._m23 = tempMatrix._m24 =     tempMatrix._m31 = tempMatrix._m32 = tempMatrix._m34 = 0;
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,tempMatrix);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_RELATIVE:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_ROTATION:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            tempMatrix = tempMatrix.ExtractRotation();
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = VRUT::Event::GET_EVT_SCENE_NODE_TRANSFORM(this->idScene, this->idSceneNode, transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_TRANSLATION:
                     {
                            relativeMatrix(prevMatrix, tempMatrix);
                            tempMatrix._m11 = tempMatrix._m22 = tempMatrix._m33 = tempMatrix._m44 = 1;
                            tempMatrix._m12 = tempMatrix._m13 = tempMatrix._m14 = tempMatrix._m21 = tempMatrix._m23 = tempMatrix._m24 =     tempMatrix._m31 = tempMatrix._m32 = tempMatrix._m34 = 0;
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_USE_RELATIVE:
                     {
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_USE_ROTATION:
                     {
                            tempMatrix = tempMatrix.ExtractRotation();
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = VRUT::Event::GET_EVT_SCENE_NODE_TRANSFORM(this->idScene, this->idSceneNode, transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              case WORLD_TRANSFORM_USE_TRANSLATION:
                     {
                            tempMatrix._m11 = tempMatrix._m22 = tempMatrix._m33 = tempMatrix._m44 = 1;
                            tempMatrix._m12 = tempMatrix._m13 = tempMatrix._m14 = tempMatrix._m21 = tempMatrix._m23 = tempMatrix._m24 =     tempMatrix._m31 = tempMatrix._m32 = tempMatrix._m34 = 0;
                            tempMatrix._m41 *= scale;
                            tempMatrix._m42 *= scale;
                            tempMatrix._m43 *= scale;
                            const MATRIX * curr = node->GetLocalTransMatrix();
                            const MATRIX * w = node->GetWorldTransMatrix();
                            MATRIX transform = this->transformMatrixRegardWorld(&tempMatrix,curr, w);
                            wxCommandEvent evt = Event::GET_EVT_SCENE_NODE_TRANSFORM(idScene,idSceneNode,transform);
                            wxCommandEvent ev = Event::GET_EVT_RENDER_UPDATE(idScene);
                            module->PostToKernel(evt);
                            module->PostToKernel(ev);
                            break;
                     }
              default:
                     {
                            LOGWARNING(wxString::Format(wxT("<TrackingManipulator> Bad TransformMode used: %i"), mode));
//                          LOG(wxT("DEFAULT"));
                     }
                     break;
              }
       }
       prevMatrix = bodyMatrix;
       changed = true;
       return;
}
wxString TTableEntry::GetAsString()
{
       wxString dump = wxT("");
       dump <<       idScene << wxT(" ") << idSceneNode << wxT(" ") << idBody << wxT(" ") << bodyType
               << wxT(" ") << mode << wxT(" ") << transformCondition.PressedMask()<< wxT(" ")
               <<    transformCondition.ReleasedMask() << wxT(" ") << transformCondition.Control1()
               << wxT(" ") << transformCondition.Control2() << wxT(" ") << scale;
       return dump;
}

TrackingTable::TrackingTable()
{
       iterator    = -1;
       idBody     = -1;
       SceneId     = -1;
       SceneNodeID = -1;
}
TrackingTable::~TrackingTable()
{}
void TrackingTable::AddRow(int bodyID, Body::BodyType type, int sceneId, int SceneNode, Condition condition, TTableEntry::TransformMode mode, float scale)
{
       TTableEntry entry(bodyID, type, sceneId, SceneNode, condition, mode,scale);
       table.push_back(entry);
}
void TrackingTable::AddRow(int bodyID, Body::BodyType type, int sceneId, int SceneNode, int pressed, int released, float ctrl1, float ctrl2, TTableEntry::TransformMode mode, float scale)
{
       Condition condition(pressed,released,ctrl1, ctrl2);
       TTableEntry entry(bodyID, type, sceneId, SceneNode, condition, mode,scale);
       table.push_back(entry);
}
void TrackingTable::UpdateRow(int bodyID, Body::BodyType type, int sceneID, int sceneNode, Condition condition, TTableEntry::TransformMode mode, float scale)
{
       int iter = this->GetFirstRow(bodyID, type, sceneID, sceneNode);
       if (iter == -1)
       {
              AddRow(bodyID, type, sceneID, sceneNode, condition, mode, scale);
       }
       else
       {
              UpdateRow(iter, condition, mode, scale);
       }
}
void TrackingTable::UpdateRow(int row, Condition condition, TTableEntry::TransformMode mode, float scale)
{
       if (row >= (int)table.size()) return;
       table[row].SetCondition(condition);
       table[row].SetTransformMode(mode);
       table[row].SetScale(scale);
}

int TrackingTable::GetFirstRow(int idBody, Body::BodyType type, int scene, int sceneNode)
{
       iterator = -1;
       this->idBody = idBody;
       this->type = type;
       this->SceneId = scene;
       this->SceneNodeID = sceneNode;
       for (size_t i = 0; i < table.size(); i++)
       {
              if (table[i].GetBodyID() == idBody && table[i].GetBodyType() == type && table[i].GetSceneID() == scene && table[i].GetSceneNodeID() == sceneNode)
              {
                     iterator = (int)i;
                     return iterator;
              }
       }
       return iterator;
}
int TrackingTable::GetNextRow()
{
       if (iterator == -1) iterator = 0;
       for (size_t i = iterator; i < table.size(); i++)
       {
              if (table[i].GetBodyID() == idBody && table[i].GetBodyType() == type && table[i].GetSceneID() == SceneId && table[i].GetSceneNodeID() == SceneNodeID)
              {
                     iterator = (int)i;
                     return iterator;
              }
       }
       iterator = -1;
       return iterator;
}
void TrackingTable::SetScale(int row, float scale)
{
       if (row >= (int)table.size()) return;
       table[row].SetScale(scale);
}
void TrackingTable::SetTransformMode(int row, TTableEntry::TransformMode mod)
{
       if (row >= (int)table.size()) return;
       table[row].SetTransformMode(mod);
}
void TrackingTable::SetCondition(int row,Condition cond)
{
       if (row >= (int)table.size()) return;
       table[row].SetCondition(cond);
}
float TrackingTable::GetScale(int row)
{
       //if (row >= (int)table.size()) return 0;
       return table[row].GetScale();
}
TTableEntry::TransformMode TrackingTable::GetTransformationMode(int row)
{
       //if (row >= (int)table.size()) return ;
       return table[row].GetTransformationMode();
}
int TrackingTable::GetSceneID(int row)
{
       //if (row >= (int)table.size()) return ;
       return table[row].GetSceneID();
}
int TrackingTable::GetSceneNodeID(int row)
{
       //if (row >= (int)table.size()) return ;
       return table[row].GetSceneNodeID();
}
Condition TrackingTable::GetCondition(int row)
{
       //if (row >= (int)table.size()) return ;
       return table[row].GetCondition();
}
TTableEntry * TrackingTable::getTableEntry(int row)
{
       //if (row >= (int)table.size()) return ;
       return &table[row];
}
void TrackingTable::ProcessTable(Body::BodyType type, int bodyID, MATRIX bodyMatrix, int buttons, float ctrl1, float ctrl2, VRUT::SceneModule *module)
{
//     LOG(wxT("Processing table..."));
//     LOG(wxString::Format(wxT("type %i, id %i"), type, bodyID));
       if (ctrl1 < -1 || ctrl1 > 1) ctrl1 = 0;
       if (ctrl2 < -1 || ctrl2 > 1) ctrl2 = 0;
       for (size_t i = 0 ; i < table.size(); i++)
       {
//            LOG(wxString::Format(wxT("Entries:: type %i, id %i"), (int)table[i].GetBodyType(), table[i].GetBodyID()));
              if (bodyID == table[i].GetBodyID() && type == (int)table[i].GetBodyType())
              {
//                   LOG(wxT("Entry found..."));
                     table[i].generateEvent(bodyMatrix, buttons, ctrl1, ctrl2, module);
              }
       }
}
bool TrackingTable::InsertLine(int bodyID, Body::BodyType type, int sceneID, int sceneNode, int pressed, int released, float ctrl1, float ctrl2, TTableEntry::TransformMode mode, float scale)
{
       if (type != Body::B6DF2) // check if the body doesn't have controls
       {
              ctrl1 = ctrl2 = 0;
       }
       if (type == Body::B6D || type == Body::B3D || type == Body::BGL) // check if the body doesn't have buttons
       {
              pressed = released = 0;
       }
       std::vector<TTableEntry>::iterator i;
       for (i = table.begin(); i != table.end(); i++)
       {
              Condition cond = (*i).GetCondition();
              if ((*i).GetBodyID()             == bodyID    &&
                     (*i).GetBodyType()           == type      &&
                     (*i).GetSceneID()            == sceneID   &&
                     (*i).GetSceneNodeID()        == sceneNode &&
                     cond.PressedMask()           == pressed   &&
                     cond.ReleasedMask()          == released  &&
                     cond.Control1()              == ctrl1     &&
                     cond.Control2()              == ctrl2       &&
                     (*i).GetTransformationMode() == mode      &&
                     (*i).GetScale()              == scale       ) return false;
       }
       // if not returned after the same row found...
       this->AddRow(bodyID, type, sceneID, sceneNode, pressed, released, ctrl1, ctrl2, mode, scale);
       return true;
}
bool TrackingTable::EraseLine(int bodyID, Body::BodyType type, int sceneID, int sceneNode, int pressed, int released, float ctrl1, float ctrl2, TTableEntry::TransformMode mode, float scale)
{
       if (type != Body::B6DF2) // check if the body doesn't have controls
       {
              ctrl1 = ctrl2 = 0;
       }
       if (type == Body::B6D || type == Body::B3D || type == Body::BGL) // check if the body doesn't have buttons
       {
              pressed = released = 0;
       }
       std::vector<TTableEntry>::iterator i;
       for (i = table.begin(); i != table.end(); i++)
       {
              Condition cond = (*i).GetCondition();
              if ((*i).GetBodyID()             == bodyID    &&
                     (*i).GetBodyType()           == type      &&
                     (*i).GetSceneID()            == sceneID   &&
                     (*i).GetSceneNodeID()        == sceneNode &&
                     cond.PressedMask()           == pressed   &&
                     cond.ReleasedMask()          == released  &&
                     cond.Control1()              == ctrl1     &&
                     cond.Control2()              == ctrl2       &&
                     (*i).GetTransformationMode() == mode      &&
                     (*i).GetScale()              == scale       )
              {
                     table.erase(i);
                     return true;
              }
       }
       return false;
}
void TrackingTable::ClearTable()
{
       table.clear();
}

wxString TrackingTable::GetAsString()
{
       wxString dump = wxT("");
       size_t  max = table.size();
       for (size_t i = 0; i < max; i++)
       {
              dump << table[i].GetAsString() << wxT("\n");
       }
       return dump;
}
void TrackingTable::WriteToLog()
{
       size_t max = table.size();
       if (max == 0) 
       {
              LOG(wxT("<TrackingManipulator> Table empty!"));
              return;
       }
       else
       {
              wxString dump = wxT("<TrackingManipulator> Table: (scene node type id mode pressed released ctrl1 ctrl2 scale)\n");
              for (size_t i = 0; i < max; i++)
              {
                     Condition c = table[i].GetCondition();
                     dump << table[i].GetSceneID() << wxT(" ") << table[i].GetSceneNodeID()
                             << wxT(" ") << table[i].GetBodyType() << wxT(" ") << table[i].GetBodyID()
                             << wxT(" ") << table[i].GetTransformationMode() << wxT(" ") << c.PressedMask()
                             << wxT(" ") << c.ReleasedMask() << wxT(" ") << c.Control1() << wxT(" ") << c.Control2()
                             << wxT(" ") << table[i].GetScale() <<wxT("\n");
              }
              LOG(dump);
       }
}
MATRIX TTableEntry::transformMatrix(const MATRIX * relative,const MATRIX * current)
{
       MATRIX cur_trans = MATRIX::Translation(current->ExtractTranslation()); // translation matrix of current
       MATRIX curr_rot = current->ExtractRotation();
       MATRIX cur_inv = cur_trans.Inverse(); // inverse matrix;
       MATRIX rel_trans = MATRIX::Translation(relative->ExtractTranslation());
       MATRIX rel_rot   = relative->ExtractRotation();
       MATRIX ret = (cur_inv * rel_rot) *(cur_trans * rel_trans);
       return ret;
}
MATRIX TTableEntry::transformMatrixRegardWorld(const MATRIX *relative, const MATRIX *nodeLocalMatrix, const MATRIX * nodeWorldMatrix)
{
/*
       MATRIX rot = nodeWorldMatrix->ExtractRotation();
       MATRIX rot_back = nodeLocalMatrix->ExtractRotation();
       relativeMatrix(rot_back, rot);
       relativeMatrix(nodeWorldMatrix->ExtractRotation(), rot_back);

       MATRIX cur_trans = MATRIX::Translation(nodeLocalMatrix->ExtractTranslation()); // translation matrix of current
       MATRIX cur_inv = cur_trans.Inverse(); // inverse matrix;
       MATRIX rel_trans = MATRIX::Translation(relative->ExtractTranslation());
       MATRIX rel_rot   = relative->ExtractRotation();
       //MATRIX ret = (cur_inv * rel_rot) *(cur_trans * rel_trans);
       MATRIX transform = (((cur_inv * rot_back) * (*relative)) * rot) * cur_trans;
       return transform;
*/
       MATRIX wrld_rot = nodeWorldMatrix->ExtractRotation();
       MATRIX wrld_inv = wrld_rot;
       wrld_inv.InvertThisPrecise();
       MATRIX cur_trans = MATRIX::Translation(nodeLocalMatrix->ExtractTranslation()); // translation matrix of current
       MATRIX cur_inv = cur_trans.Inverse(); // inverse matrix;
       MATRIX rel_trans = MATRIX::Translation(relative->ExtractTranslation());
       MATRIX rel_rot   = relative->ExtractRotation();
       //MATRIX ret = (cur_inv * rel_rot) *(cur_trans * rel_trans);
       MATRIX transform = ((((cur_inv * wrld_rot) * rel_rot) * rel_trans) * wrld_inv) * cur_trans;
       return transform;
       
}

---