Figuring out linear algebra for 3d transformations and I've been stumped by RigidBody's physics

jhagedor

I've been trying to get really comfy with 3d space so I'm learning linear algebra and going through some example code line-by-line to try and understand how exactly it gets implemented and I found it only functioned when the target's z-position was greater than the follower's. So half the time and only on one plane.

(just to see for yourself and let me know if I'm mistaken)

https://docs.godotengine.org/en/stable/tutorials/physics/rigid_body.html

I went on to try my own solution to see if I'm grasping the math involved and it's working... slightly more than half the time.

(here's my new solution)

breakdown: line 17: get the vector from the Follower to the Target line 18: get the vector from the Follower to the Target relative to the follower's current rotation using xform_inv() line 19: get the axis perpendicular to the angle between the follower and the target by taking the cross product (this also automatically gave the direction to turn which was a problem with the sample solution too) line 20: get the angle between the follower and target in radians line 22/23: a hack that helps one edge case but overall changes nothing by its presence or absence line 25: then plug it in to state.set_angular_velocity() the same way the sample code did

It works 360 deg if I keep the target on the same y coordinate as the follower which is great. It also works moving in 3d as long as the target's z-position is greater than the followers again. The really weird thing is the way in which it fails. I'll show some pics to illustrate.

(it works moving strictly around the y-axis at any angle)

(as well as the x-axis)

(after initialization, as long as the target doesn't move, the follower points at it from a neutral position to any angle without issue)

(The problem comes up if the target's z-coordinate is less than the follower's AND it's y-coordinate is different from the follower's AND the target moves. That's when the follower flips around. What's even weirder is if I slow it down I can see that a small singular movement of the target is still followed but the follower then begins to slowly destabilize more and more until it flips around.)

It also doesn't tumble if I set_angular_velocity around strictly either the x or y axis, which makes me wonder if it actually has something to do with the implementation of that function. I'm still pretty inexperienced so I've never looked that deep before. If anyone has ANY words of advice or can figure out what's going on I would be so very grateful! I've been working on this for two days now and it's killing me.

TwistedTwigleg

Unfortunately I do not have a solution, but I can confirm that look_at and the function in the RigidBody documentation is kinda unstable at times, especially around certain planes (X, Y, or Z). I found that using Quaternion based rotation can sometimes help, but the best solution I’ve found is to use two nodes, one for rotation on just the Y axis, and then a child node to handle X and Z:

Y_node
- X_Z_node

Then you can use look_at with relatively stable results by calling look_at on the Y_node by flattening the Y coordinate (so it only rotates around the Y axis) and then call look_at on the X_Z_node after that.

Unfortunately though, I have not found such a solution for RigidBody nodes, since it doesn’t really work with the two-node solution.

jhagedor

Thank you, that's an interesting solution! When you mention the look_at method are you referring to the built-in function or a custom implementation using forces like the one I'm trying?

This whole journey started because the RigidBody tutorial page ends with the assertion that the built-in look_at method is unstable for RigidBodies and offers up a general solution that claims to be consistent. I found it to be consistent only on a 2d-plane and only when the target's global X coordinate is greater than the seeker's global X coordinate (basically when the target is to the right of the seeker). My attempt got as far as complete consistency on a 2d plane but had the same weird X coordinate relationship bug for 3d space.

I know that actual characters controlled by physics isn't usually ideal, but a tempting case I want to explore is with "flying" characters that get pushed around by wind and knocked around by projectiles. In that case I would want to see if they could purely use force to handle steering in 3d space.

Looks like the next journey's all about quaternions! (what are they? how do they help? how are they used?) If you have any helpful advice or resources please lmk!