Not interpolate quaternion on shortest path?

Question

Hi,

I have been searching a long time but I did not find something that hints at a solution. Basically I want to smoothly interpolate between two Rotations. However I do not want to interpolate along the shortest path.

When I use Quaternion.Lerp, SLerp or RoateTowards it would rotate 90 degrees when interpolating between (in eulers) (0,270,0) and (0,0,0), but I want it to rotate 270 degrees.

I tried using eulerAngles on both source and target rotation, interpolating the vectors and reconverting them into quaternions with Quaternion.Euler but that gives me the same results.

Is there an inbuilt way to use this "non-optimal" interpolation?

greetings

Answer 1

Best Answer

Answer by robertbu · Jun 21, 2013 at 02:53 PM

If you do some searching around on UA, you will find a number of answers to this question. One answer is to treat eulerAngles as write-only and maintain your own Vector3. Here is one of those answers:

http://answers.unity3d.com/questions/475760/rotation-direction-in-coroutine.html

Add comment · Show 6 · Share

robertbu · Jun 21, 2013 at 03:37 PM 0

Share

@FreetimeCoder - eulerAngles has a habit of changing representation on you. You can get around the 0/360 boundary by changing the representation in the Vector3 you maintain.

FreetimeCoder · Jun 23, 2013 at 07:51 AM 0

Share

Ok, but is there a reason not to use localEulerAngles? From what I can tell it does exactly what I need.

robertbu · Jun 25, 2013 at 11:57 PM 0

Share

@FreetimeCoder - As explained in the answer at the link provided, eulerAngles can change its representation. Write a bit of code that sets the eulerAngles to (180,0,0), and then use a Debug.Log() statement to read it back. You will get (0,180,180). eulerAngles changes in a predictable pattern, so if you are careful, it may work for you. But as stated, it is safer to keep your own Vector3 and never read eulerAngles.

FreetimeCoder · Jun 26, 2013 at 01:41 PM 0

Share

I see what you mean, however I cannot use that method because the first time I get a rotation is when the level started and I read localEulerAngles from the gameobject's transformation. I never modify it afterwards only interpolate something else between different objects' transformations.

FreetimeCoder · Jun 30, 2013 at 03:00 PM 0

Share

Ok, I found that transform.localRotation is much better than localEulerAngles, because the later sometimes even changes between in-editor and in-game while the localRotation Quaternion does not.

(I must confess this again takes me back to the "shortest path" thing, but I have given up on trying to acheive a perfect solution)

I think this solves this topic.

Show more comments

Answer 2

Answer by Maeslezo · Jan 27, 2017 at 09:14 AM

I had the same problem, so I have written the lerp and slerp myself, with a flag to indicate whether you want to force the short way or not. I am pretty sure that Unity checks that to invert the rotation. With this code, you can indicate if you want that behaviour.

I have checked myself and it seems it works ok, but check yourself just in case:

 public static class QuaternionExtension
  {
      public static Quaternion Lerp(Quaternion p, Quaternion q, float t, bool shortWay)
      {
          if (shortWay)
          {
              float dot = Quaternion.Dot(p, q);
              if (dot < 0.0f)
                  return Lerp(ScalarMultiply(p, -1.0f), q, t, true);
          }
  
          Quaternion r = Quaternion.identity;
          r.x = p.x * (1f - t) + q.x * (t);
          r.y = p.y * (1f - t) + q.y * (t);
          r.z = p.z * (1f - t) + q.z * (t);
          r.w = p.w * (1f - t) + q.w * (t);
          return r;
      }
  
      public static Quaternion Slerp(Quaternion p, Quaternion q, float t, bool shortWay)
      {
          float dot = Quaternion.Dot(p, q);
          if (shortWay)
          {
              if (dot < 0.0f)
                  return Slerp(ScalarMultiply(p, -1.0f), q, t, true);
          }
  
          float angle = Mathf.Acos(dot);
          Quaternion first = ScalarMultiply(p, Mathf.Sin((1f - t) * angle));
          Quaternion second = ScalarMultiply(q, Mathf.Sin((t) * angle));
          float division = 1f / Mathf.Sin(angle);
          return ScalarMultiply(Add(first, second), division);
      }
  
  
      public static Quaternion ScalarMultiply(Quaternion input, float scalar)
      {
          return new Quaternion(input.x * scalar, input.y * scalar, input.z * scalar, input.w * scalar);
      }
  
      public static Quaternion Add(Quaternion p, Quaternion q)
      {
          return new Quaternion(p.x + q.x, p.y + q.y, p.z + q.z, p.w + q.w);
      }
  }

Add comment · Show 3 · Share

LevonVH · Jan 28, 2021 at 12:24 PM 0

Share

Great solution @$$anonymous$$aeslezo ! Thank you.

Bunny83 · Jan 28, 2021 at 01:17 PM 0

Share

An implementation that's a bit more optimised would be:

   public static Quaternion Slerp(Quaternion p, Quaternion q, float t, bool shortWay)
   {
       float dot = Quaternion.Dot(p, q);
       float sign = (shortWay && dot < 0.0f) ?-1f : 1f;
       float angle = Mathf.Acos(dot * sign);
       float division = 1f / Mathf.Sin(angle);
       float t0 = Mathf.Sin((1f - t) * angle) * division * sign;
       float t1 = Mathf.Sin((t) * angle) * division;
       return new Quaternion(
           p.x*t0 + q.x * t1,
           p.y*t0 + q.y * t1,
           p.z*t0 + q.z * t1,
           p.w*t0 + q.w * t1
       );
   }

Note that I currently can't test this method as I don't have Unity at hand. I can also not guarantee that it works as I haven't verified the original method, but it looks right. My version is just a simplification / inlining of the original post. It reduces the method calls and also the required multiplications

krisventure · Mar 18, 2021 at 11:04 PM 0

Share

Imagine if Unity made it easy for us and added this solution and all you'd have to do is to set an additional bool param, wouldn't that be awesome ... I've had to look up this issue so many times over the years and always ended up implementing some length workaround.

Answer 3

Answer by wolfgraphicsLLC · Jan 28, 2021 at 07:06 PM

ok @FreetimeCoder i know of at least 2 ways to fix that off the top of my head first as a dev not as a just programmer how is your object set up wat does the scenario look like in the scene view and as well the inspector setting s and setup in hierarchy cold you either upload a sort video or a couple screen shots showing this? or another option is you could go to discord to https://discord.gg/gjWDxcPC and go to the programing and general unity channel and @ john nic?9wolfgraphicsllc) that's me I am one of the tutors and moderators there as well there is a create a ticket channel where you can get a little more focused assistance. and i would be glad to look it over and walk you through and trouble shoot it with you for like i always say when it comes to dev work and coding alike there is always more than one way to skinn a cat

Add comment · Share

Not interpolate quaternion on shortest path?

3 Replies

Your answer

Follow this Question

Related Questions