Horde3D

// The implementation I am using uses references and nixes the scale value, but the theory is the same.
void h3dutGetNodeWorldTransform(H3DNode node, float* tx,float* ty,float* tz,float* rx,float* ry,float* rz,float*,float* sx, float* sy, float* sz)
{
    H3DNode parent;
   
    float tra_x,tra_y,tra_z;
    float rot_x,rot_y,rot_z;
    float sca_x,sca_y,sca_z;
   
    do
    {
        parent = h3dGetNodeParent(node);
        h3dGetNodeTransform(node,&tra_x,&tra_y,&tra_z,&rot_x,&rot_y,&rot_z,&sca_x,&sca_y,&sca_z);
       
        *tx+=tra_x;*ty+=tra_y;*tz+=tra_z;
        *rx+=rot_x;*ry+=rot_y;*rz+=rot_z;
        *sx+=sca_x;*sy+=sca_y;*sz+=sca_z;
       
    }while(parent!=H3DRootNode);
}

// assume the following
typedef boost::unordered_map<H3DNode, boost::shared_ptr<btCollisionObject> > NodeCollisionMap;
typedef std::pair<H3DNode, boost::shared_ptr<btCollisionObject> > CollisionMapPair;

void Prop::Update(float time)
{
    // Set the orientation of the props root node
    btQuaternion orientation((btScalar)rotX,(btScalar)rotY,(btScalar)rotZ);
    btTransform trans(orientation,btVector3(x,y,z));
    collision_object->setWorldTransform(trans);

    // explicit transforms stored by the prop object and are set when a rigid body is attached.
    h3dSetNodeTransform(node,x,y,z,rotX,rotY,rotZ,scalX,scalY,scalZ);

    BOOST_FOREACH(CollisionMapPair pair, collision_map)
    {
        float mat[4][4];
        h3dGetNodeTransMats(pair.first,NULL,mat);

        float X = mat[3][0];float Y = mat[3][1];float Z = mat[3][2];
       
        // Still need to decompose the matrix to aquire the rotation of the node.
        btQuaternion orientation((btScalar)rx,(btScalar)ry,(btScalar)rz);
        btTransform trans2(orientation,btVector3(X,Y,Z));
        pair.second->setWorldTransform(trans2);
    }
}

void Actor::Update(float time)
{
    BOOST_FOREACH(CollisionMapPair pair, collision_map)
    {
        const float** mat;
        float* trans;
        float* rot;
        float* scal;
        h3dGetNodeTransMats(pair.first,NULL,mat);

        decompose(mat,trans,rot,scal);

        btQuaternion orientation((btScalar)rot[0],(btScalar)rot[1],(btScalar)rot[2]);
        btTransform btrans(orientation,btVector3(trans[0],trans[1],trans[2]));
        pair.second->setWorldTransform(btrans);
    }
    // if it has a core object defined
    if(core_object && asUpdate > 0)
    {
        int r;
        Stage::I()->getContext()->Prepare(asUpdate);
        Stage::I()->getContext()->SetArgFloat(0,time);
        r = Stage::I()->getContext()->Execute();
        if(r != asEXECUTION_FINISHED)
        {
            if(r == asEXECUTION_EXCEPTION)
            {
                LOG("An exception '"+string(Stage::I()->getContext()->GetExceptionString())+
                    "' occurred. Please correct the code and try again.",FATAL);
                Engine::I()->Kill();
            }
        }
    }
}