Align compass needle to compass surface

Unfortunately, that does it even worse. The needle sticks now completly out, like if I had not done the “ProjectOnPlane” method.

But about your forward vector. I don’t think that it is neccessary to take the position and add the direction to it. The direction itself was always enough for me in all games I created so far. It’s because you set the blue arrow of this object in this direction, independent of it’s current position. So like the object is the origin (0,0,0)

I also tried it with something like this:

Vector3 dir = GetNearestExitPosition() - pointer.transform.position;
dir.y = 0;
pointer.transform.rotation = Quaternion.Slerp(pointer.transform.rotation, Quaternion.LookRotation(dir), Time.deltaTime * rotationSpeed);

But with it I also couldn’t stop the needle from rotating around it’s local X and Z axis. I only want that it rotates around it’s local Y axis.

Could I see the ProjectOnPlane function please?

ProjectOnPlane is an Unity function in Vector3.

It stays now in the X-Z world plane and unfortunately not in the X-Z local plane. It also glitches very fast between two orthogonal states. One of them in the exit direction.

Hmmmmm…. I know I’ve done something like this before. Gimmie a bit, and I’ll post it here if you still need it.

Yes. I will take whatever you have for me.

Ok, here’s what I got:

public class Compass : MonoBehaviour
{
     public Transform needle;
     public Transform target;
 
     void Update()
     {
          Vector3 relativePos = target.position - transform.position;
          relativePos.y = 0f;
          Quaternion rotation = Quaternion.LookRotation(relativePos, Vector3.up);
          needle.rotation = transform.rotation * rotation;
     }
}

The only thing with this, is that it doesn’t take the compass rotation into account for getting the direction. So what that means, is if the target is directly behind you, the needle will be at the bottom of the compass, even if the compass is upside-down.

Lemme know how this works for you. =)

Another nice trick, but this also does not work as intended. The pointer does not rotate at all now. It seems that the rotation of the main compass body, which is done by picking up and dragging around, will be negated with your code. This results into, that the pointer shows always in the east direction of the compass (not the world). But it should point always to the nearest exit, of course.

The compass started in north direction, so your code make it stick to the east. Perhaps this picture of the parent structure helps you.

That is odd, because for me, the needle at least moves.

This is what it looks like on my end.

That looks great. I try a few variations of your code and see what I can do.

Nevertheless, I saw that you only have a sphere as a pointer for the compass, which is displaced from the center. Try adding a cube which is connected from the center to the sphere by stretching it and look if this cube rotates awkwardly.

This is basically what my first code did. The direction is fine, but it rotates weirdly around the blue axis.

Hey I found something. I came up with another approach based on your last code. It looks like this:

Vector3 dir = GetNearestExitPosition() - pointer.transform.position;
Vector3 pointerForward = pointer.transform.forward;
dir.y = pointerForward.y = 0f;
float angle = -Vector3.SignedAngle(dir, pointerForward, transform.up);
Quaternion endRotation = pointer.transform.localRotation * Quaternion.Euler(0, angle, 0);
pointer.transform.localRotation = Quaternion.Slerp(pointer.transform.localRotation, endRotation, Time.deltaTime * rotationSpeed);

So what it actually do is:

• get the direction where it has to look and where it looks at the moment
• set the y value to 0, so that we are working on the X-Z plane
• calculate now the angle between both directions
• calculate the end rotation by adding the angle only to the y component to the local rotation of the pointer
• do the transition smoothly with the slerp method

It is nearly perfect, but if the compass stands, so is orthogonal to the X-Z world plane, the arrow is about +/-45° off. I can live with this compromise, except you find a better solution.

I’ll see what I can do, and for mine in the video, the sphere isn’t the needle. There’s an empty game object at the center, and the sphere is just moved forward a little bit. stretching a cube (or any model really) might distort with the rotation.

Yeah I know. So basically this hierachy:

1. Compass
2. Key Point/Center (empty GO, where we rotate with script)
3. 1. Needle Top (your sphere) + 2. Needle Body (the cube I tell you, stretched from center to needle top)

It’s because, with only a sphere as a pointer, you don’t see if the pointer does a weird rotation around it’s forward axis.

I was trying to avoid doing it like this, but try this, and lemme know:

 needle.LookAt(target);
 Vector3 eulers = needle.localEulerAngles;
 eulers.x = eulers.z = 0f;
 needle.localEulerAngles = eulers;

Edit: this seems to have trouble with elevations, but if you just adjust it so they have the same y it should work better.

Edit 2: I also have an off screen target indicator I made on here a while back. I bet you or I could adjust it to work in 3d space instead of just UI.

heres a link to it if you wanna try something:

https://github.com/Mouledoux/ConnectedHome/blob/master/Assets/Scripts/TargetIndicator.cs

Haha so simple and it works perfectly. Nicely done! A slerp is not possible this way, because with LookAt you fix the pointer every frame in target direction, but I take it. It looks “smooth” enough if I carry the compass around.

Your TargetIndicator script looks good too. But I don’t think that we need that much code for my problem. Your other small code is good enough. It works pretty well.