Jump to content
  • Advertisement
Sign in to follow this  

[C#] Quaternion methods giving slightly different results

This topic is 3379 days old which is more than the 365 day threshold we allow for new replies. Please post a new topic.

If you intended to correct an error in the post then please contact us.

Recommended Posts

Why do I get slightly different values for the following two methods using Quaternions? METHOD 1:
            // AddScaledVector (consise XNA method)
            orientation += new Quaternion(rotation * duration * 0.5f, 0) * orientation;   // Don't forget the 0.5f, otherwise you will rotate at 2x radians per second
            Quaternion p = orientation;
            p = AddScaledVector(rotation, duration, p);

        public Quaternion AddScaledVector(Vector3 vector, float scale, Quaternion quaternion)
            Quaternion q = new Quaternion(
                vector.X * scale,
                vector.Y * scale,
                vector.Z * scale

            q *= quaternion;

            quaternion.W += q.W * 0.5f;
            quaternion.X += q.X * 0.5f;
            quaternion.Y += q.Y * 0.5f;
            quaternion.Z += q.Z * 0.5f;

            return quaternion;

METHOD 1 returns: {X:0.05399736 Y:0.04901603 Z:0.04899952 W:0.9961349} METHOD 2 returns: {X:0.05322018 Y:0.04909545 Z:0.04899951 W:0.9969998} Thank you.

Share this post

Link to post
Share on other sites
XNA? the constructor for the quaternion is (x, y, z, w), you have (0, x, y, z) but those values do seem very close so maybe what your doing is the right order.

I guess they could be normalising at some point. I tried normalising your returned Quaternion but the vaues are still off.

I'm having trouble seeing whats going wrong here. Out of curiosity, why are you trying to replace a perfectly readable line of code with a pretty ugly method that doesn't work as well?

If there's no other reason than the method name (readability) then just stick that Method 1 line intot he method 2 code.

Share this post

Link to post
Share on other sites
The reason why I am using the second method is because that is the exact method used in the Cyclone physics engine, which I am porting over to C#.

I still have concerns over the Quaternion methods found in the code though and I am slightly confused by the following lines in the source code to the Cyclone physics engine:

Quaternion q;
q.addScaledVector(rotationDirection, rotationAmount * ((real)0.5));

As I understand the q.addScaledVector method is as follows:

void addScaledVector(const Vector3& vector, real scale)
Quaternion q(0,
vector.x * scale,
vector.y * scale,
vector.z * scale);

q *= *this;

r += q.r * ((real)0.5);
i += q.i * ((real)0.5);
j += q.j * ((real)0.5);
k += q.k * ((real)0.5);

So I was wondering why there is another 0.5 being fed into the method and why it would be necessary, or whether it is a typo.

Also, considering the following line:

orientation.addScaledVector(rotation, duration);

can be coded in XNA as:

orientation += new Quaternion(rotation * duration * 0.5f, 0) * orientation;

then can the line:

q.addScaledVector(rotationDirection, rotationAmount * ((real)0.5));

be coded as:

orientation += new Quaternion(rotation * duration * 0.5f * 0.5f, 0) * orientation;


orientation += new Quaternion(rotation * duration * 0.25f, 0) * orientation;

I guess in all cases in don't need to normalize the Quaternion either?

Share this post

Link to post
Share on other sites
Sign in to follow this  

  • Advertisement

Important Information

By using GameDev.net, you agree to our community Guidelines, Terms of Use, and Privacy Policy.

GameDev.net is your game development community. Create an account for your GameDev Portfolio and participate in the largest developer community in the games industry.

Sign me up!