I'm attempting to rework some code that I wrote early on and I'm not the best at math, so what I ended up doing to avoid figuring out a math problem that puzzled me for several days was as follows:

Problem: figure out how to get the correct angle of the players direction of travel relative to the "north pole" on my 3d planet... for generating a stinking simple compass display.

Honestly, I think I spent almost a full week trying to get this to work..  I looked up nearly every math heavy google result I could to try and make it work but I just couldn't wrap my head around enough of it to get it going without some trickery.  So, even though I've learned a LOT since then, I really don't want to spend hours and hours trying to look up the same problem that I really wasn't effective at solving on my own the first time.. haha

My Trickery:

1) I was having trouble figuring out how to implement the correct math for half of the problem(maybe the only real math part...).  So, instead, I created a child object of the player character and gave it this code:

(the code was not actually doing anything at all, so I've removed it..., see below example where the gymbal object rotation is set, the code here was doing similarly)..

My goal, and the effect, was to define a constant source of angle information so I didn't have to do the math.   It works, quite effectively..  I just feel like there's a much much much easier(more efficient) way to do it that I can't sort out (mathematically IN c#)...

2) the second part of the trickery is using the data from the "gymbal" object instead of calculating the math directly.

//Code to determine player direction of travel NSEW, on a spheroid planet.

Vector3 point2origin = transform.position - planet.transform.position;  //origin is center of planet
Vector3 point2closestPointOnLine = point2origin - Vector3.Dot(point2origin, planet.transform.up) * planet.transform.up;

//(playerGymbal) == Generic game object parented to player character object(keeps it moving with the pc).
playerGymbal.transform.rotation = Quaternion.FromToRotation(-transform.up, point2closestPointOnLine) * transform.rotation;

//Here's the number I actually need.
float angle = SignedAngle(playerGymbal.transform.forward, planet.transform.up, playerGymbal.transform.position);

String nsew = "";

if (angle < -5 && angle > -85)
{nsew = "SE";}
if (angle <= 5 && angle >= -5)
{nsew = "S";}
if (angle > 5 && angle < 85)
{nsew = "SW";}
if (angle >= 85 && angle <= 95)
{nsew = "W";}
if (angle > 95 && angle < 175)
{nsew = "NW";}
if (angle >= 175 || angle <= -175)
{nsew = "N";}
if (angle > -175 && angle < -95)
{nsew = "NE";}
if (angle >= -95 && angle <= -85)
{nsew = "E";}
Dir.text = nsew;

So, ignoring the pile of ifs and I'm sure a few other nasty code smells, does anybody see my solution clearly?  I just want to simplify this process and get rid of the extra gymbal object and its Update loop. 

If I wasn't worried about optimization, or could use it as a helpful visual aid, I would just keep it because I think I clevered my way out of that problem pretty creatively..  But nope, it's just an invisible object using resources..

Anyhow, thanks for checking it out, any help would be greatly appreciated!

To summarize, I've got:

Planet's position in 3d space.

Player's position/rotation in 3d space.

North Pole's position in 3d space.

How do I calculate the resulting angles as above(or similar), simply, without all the extra trickery?

An important point:

The player character's "gymbal" object, always points towards the line running from the north pole to the south pole, and it rotates relative to the player's rotation, so that's how the extra object saved me from figuring out the math...

I failed to mention that anywhere above.. sorry.

Haha, so I guess the real question here is:

How do I get a ".forward" direction from this quaternion:

Quaternion.FromToRotation(-transform.up, point2closestPointOnLine) * transform.rotation;

5 hours ago, lawnjelly said:

I have a feeling there are a lot of ways of doing this, but here's an idea off top of my head:

• If you have the player translate and rotate, then get the player transform, find the inverse (to get the player at the origin pointing in default direction)
• Transform the north pole (or a higher up point) by this inverse transform to get it relative to the player
• Use atan2 to get the yaw of the north pole relative to the players direction (in 2d) 

There's probably also some cunning ways with cross products or something.

When you say "find the inverse"  you mean?  Because the only "inverse" I currently understand is an inverse transform relative to another object as below.

I'm already gathering the latitude and longitude with these 3 lines (directly preceding the above the code post). 

//Convert player's WORLD coordinates to be relative to the planet game object.
Vector3 pos = planet.transform.InverseTransformPoint(playerOwner.transform.position).normalized;

Lat = Math.Round(Math.Asin(pos.y), 3);
Lon = Math.Round(Math.Atan2(pos.x, pos.z), 3);

So, that gives me the pitch and yaw of the players Position, relative to the north pole..

I'm beginning to wonder if I actually need to fix this anymore..  I've removed the contents of the script that was attached to the gymbal object, so it's no longer costing me an extra update loop.

So, presently to get the angle I need, instead of performing the math directly, I'm rotating an empty game object so that its up direction is always pointing towards the closest point on the planet's NS axis line, it's forward angle tracks the player's forward angle simply by being a child of the PC, so then I check the signed angle between it's forward direction and this NS axis(planet.transform.up).

I guess it's still costing me extra compute cycles for the rotations and translations, so if I can figure out the math only solution I'll use it.

Thanks @Gnollrunner!  Now that's spelling it out.. (assuming you didn't mess up anywhere, haha)

I will test it out straight away and let you know what I find!

Yeah, I'm sure this will probably get me there, it vibes with the stuff I was googling when I was trying to get it working initially, but I just couldn't sort it all out.  Thanks!  Let you know in a few.

Okay, well here's my quick and dirty c# translation.  NICE MATHING @Gnollrunner!!!

Vector3 playerVec = player.transform.position - planet.transform.position;
Vector3 northVec = planet.transform.up;
Vector3 c = Vector3.Cross(playerVec, northVec);
Vector3 d = Vector3.Cross(playerVec, c);
Vector3 f = player.transform.forward;
double rads = Math.Atan2(Vector3.Dot(playerVec, Vector3.Cross(d, f)), Vector3.Dot(d, f));
double deg = (180 / Math.PI) * rads;

Debug.Log(deg.ToString());

All I had to do was realize it was returning radians and not degrees.  Perfect!