For 2 days I have been going insane over something very simple. All I am trying to do is to transform a parent matrix, and transform its child-matrices inversely, so that the child matrices keep their global transform. First I tried simply applying the localised ("internalised") inverse transform-change. It's a per-frame operation and there was always a gradual shifting away from the global position of child-object/matrices. No matter how much I experimented with the orders of rotation/translation, I couldn't get it right. The rotation part looks good and stable, but the translation always shifts away.

So I finally gave up and wanted to try something less prone to easily overlooked "inaccuracies": every frame I compute the last global position (since rotation is working, I only need the translation, I guess) by transforming the child-position with last frame's parent-transform. Then I inverse-transform this global position with the updated (this frame's) parent-transform, to re-localize the global position to the new transform. This is about as simple as it gets, and should be completely independent from any "localizing velocity issues".

... and still my child matrices are drifting away from their global positions. I just don't get it. Am I missing something?

edit: when the parent is not moving/rotating at all, parent-transformation is constant over time, and I only say...

- vector globalPos = parentTrans.transform(localPos);

- vector newLocalPos = parentTrans.tranformInv(globalPos);

... I would expect to see the child positions move with the parent, like when leaving the local positions unchanged. But even now, I get a drift away from the parent-origin, increasing with distance, for every child-position. How do I localize a position to a transform, if not by inverse-transforming???

Leaving the positions alone produces no drift, applying the 2 lines above does. Wth??? This can't be rounding errors. The shifting is much too systematic and smooth for that.

Ok, some thoughts:

//GC = global child
//LC = local child
//GP = global parent
 GC = GP * LC

// The global parent is changing, but you want to keep the local child matrix , so that it has the same global child matrix as before
LC = inv(GC) * GP

// Question: how to you calculate the invers of the GC ? 
// T =translation
// R = rotation
inv(GC) = inv(T*R) = inv(R)*inv(T) // ! , if you calculate the inverse of the translation and rotation matrix individually, you need to swap them !!

Thanks for replying.

When I do it like you say, my objects just spin around the center like mad. I am working with NVidia PhysX and the inbuilt transformation matrices.

The only setup that doesn't result in teleporting all over the place is this:

PxTransform GP = sceneTransform, LC = actor->getGlobalPose(), GC;// globalPose is only global to the scene, but the scene gets transformed itself

GC = GP * LC;
LC = GP.getInverse() * GC;

actor->setGlobalPose(LC);

But as soon as the parent-transformation deviates from identity/origin-transformation, the drifting starts again. The parent doesn't even have to be actively rotating, just a constant offset orientation from origin is enough to cause a steady drift.

Also, even though you described how to invert a matrix manually, I am not sure how to do it. I guess, I can put my trust in the inbuilt inverse-function. PxTransforms aren't really matrices anyway, but a translation vector and a rotation quaternion. I am just assuming that the functionality is the same...

I think I am finally on to the cause of this. I just converted all the transforms to actual matrices, used those the same way as in the post above, and the drifting is gone. I don't understand it at all, but what the hell...

There's still some hardly noticable, oscillating movement around the child-positions center when the parent is rotating fast, but that's nothing. You have to look very closely to see it. And now the re-localising to the new transform is working as well, without any drifting.

Two days of pure frustration only to find out that a PxTransform acts almost, but not exactly, like a matrix...