3D rotation problem, help please!

Hi all,

I'm writing a 3D space game. I have Vector3 to represent the position, velocity and angular velocity, and a Quaternion to represent the orientation of the spaceship.

Now I want to rotate the ship when I press the directional button, say turn it left when press left arrow key and turn it up when press the up arrow key. I have Vector3 to represent the force, torque etc.

I also have a method named addForceAtPoint(Vector3 force, Vector3 position) so that I can add a force at particular point, say add it on the right wing to turn it left. The position can be converted to the global coordinate no problem, but it's the force that bothers me. Say I call this:

Code:

---

//add a force on the z direction(initially the ship is moving in the positive z direction)
// at the point (30,0,0) - a point that is relative to the body, not in the global
// coordinate, it will be converted in the body of the method.

addForceAtPoint(Vector3(0,0,50), Vector3(30,0,0));

---

Now I can use the same point over and over again because it can be converted to the global coordinate every time, but I can't do the same to the force as it can't always be in the z direction. The force should always be in the direction of the spaceship. That's what I don't know how to do.

If any of you kind souls ever encountered this problem or have experience on 3D rotation problem, I will much appreciate it if you can share a solution.

Many thanks!

If the force will always be in the direction of the spaceship, use spaceship.velocity (I'm assuming that's what you mean by "in the direction of the spaceship") and be done with it.

It looks like you want to do this from scratch (ie, without using openGL or DirectX or something) because (at least in openGL) this need not be this complex because you can use a matrix stack (I believe they are there in DirectX too).

You could implement one yourself, the idea is fairly simple: You have a matrix representing the current orientation and location (a 4x4 matrix) of the ship, and one representing the next change to take place -- but this one is not relative to the ship's position, it's relative to the origin, ie, as if the ship were dead center, with no rotation. So the transformation matrix is simple, because this is no change:

Code:

---

--- orientation ------
 x-axis  y-axis  z-axis    pos
  1        0        0        0      x 
  0        1        0        0      y
  0        0        1        0      z
  0        0        0        1      need 4th row for multiplication (will always be 0,0,0,1)

---

Multiplying another 4x4 matrix by this will leave it exactly the same (ie, no matter where the ship is and how it is oriented). Which means if you (for example) change row one column 4, the product of the multiplication will have a different x-axis position. To rotate something relative to itself, multiply it's current state by a matrix tweaked w/r/t eg. the z value of the x-axis AND the x value of the z-axis (turn left or right).

That's a bit of a headache, which is why most people would use an API like openGL or DirectX, which includes simple functions like "yRotate(degrees)" that do the matrix math for you.

In any case, then you can keep the "z force" as a simple constant because you would apply it by multiplying by a matrix with a positive value in row 3 column 4.

However, I thought you could do all that with quaterions anyway?

Thank you both for the advice. I've decided to just use Quaternion to rotate the ship, i.e. when a key pressed, just rotate the ship by certain amount without adding force.

However it is still a problem to me, as the quaternion of the ship is easy to get, how do I get the new quaternion that will be used to rotate the ship? Could you give me an example please?

Thanks.

Quote:

---

Originally Posted by GOBLIN-85

Thank you both for the advice. I've decided to just use Quaternion to rotate the ship, i.e. when a key pressed, just rotate the ship by certain amount without adding force.

However it is still a problem to me, as the quaternion of the ship is easy to get, how do I get the new quaternion that will be used to rotate the ship? Could you give me an example please?

Thanks.

---

Quaternions have the axis and a rotation angle, so presumably if you know how much you want to rotate by, then you're done.

Note that rotations (whether by quaternions or any other method) are not absolute; if you've done a rotation, then further rotations will be done with respect to the new axes, not some theoretical "absolute x-y-z".

tabstop, I think the OP wants to know what the new axis will be.

Thanks tabstop, would you let me know if this works:

Code:

---

//for example, i want to rotate the ship to the left
Quaternion temp = Quaternion(pi/12, 0, 1, 0);
player->orientation *= temp;
player->orientation.normalise();

---

And after the rotation, how do I use the information stored in the quaternion to display the object on screen. I'm using openGL. Obviously glRotated is used, but I'm not sure what are the parameters to pass to it.

Quote:

---

Originally Posted by GOBLIN-85

Thanks tabstop, would you let me know if this works:

Code:

---

//for example, i want to rotate the ship to the left
Quaternion temp = Quaternion(pi/12, 0, 1, 0);
player->orientation *= temp;
player->orientation.normalise();

---

And after the rotation, how do I use the information stored in the quaternion to display the object on screen. I'm using openGL. Obviously glRotated is used, but I'm not sure what are the parameters to pass to it.

---

So type "man glRotate", or, if you're not on a *nix system, do the equivalent web search. You'll see:

Quote:

---

void glRotated( GLdouble angle,
GLdouble x,
GLdouble y,
GLdouble z )

---

and I'll bet you can guess what goes where.

Quote:

---

Originally Posted by GOBLIN-85

openGL

---

I've been fooling around with openGL for a little while and let me guess: this spaceship you are talking about is supposed to be "first person perspective", right? Like, it's not an object we see zooming around and rotating in the view right? You want to be in the ship, looking out of it?

That is why you want to use quaternions, right? Because if the answer to all these questions is not yes, I would sooner chew my own hands off than go about rotation and transformation than the way you are doing it.

Well...the spaceship I'm talking about is 3rd person perspective, while the camera follows the ship. I.e. when the ship turns, the camera turns as well, it's kinda like the control of WOW. Sorry I haven't made that clear earlier.

I'm still new to those stuff, so If you think I'm on the wrong track, would you kindly let me know and possibly show me a way please?

By the way, I still don't know if the code I wrote in post #7 would work, so if you guys don't mind, can you tell me if it is correct?

Many thanks guys.

Quote:

---

Originally Posted by GOBLIN-85

Well...the spaceship I'm talking about is 3rd person perspective, while the camera follows the ship. I.e.

---

WELL! That is pretty fancy then isn't it.

Quote:

---

I'm still new to those stuff, so If you think I'm on the wrong track, would you kindly let me know and possibly show me a way please?

---

I'm new too. I decided to avoid "quarternions" for now. Since I am kind of board with what I am supposed to be doing, maybe I will take a little time to see if what I am thinking of is possible -- just using the matrix stack and the rotate/transform functions. I will admit thus far I've been working on simpler tasks than the 3rd person perspective flying ship.

Quote:

---

Originally Posted by GOBLIN-85

Well...the spaceship I'm talking about is 3rd person perspective, while the camera follows the ship. I.e. when the ship turns, the camera turns as well, it's kinda like the control of WOW. Sorry I haven't made that clear earlier.

I'm still new to those stuff, so If you think I'm on the wrong track, would you kindly let me know and possibly show me a way please?

By the way, I still don't know if the code I wrote in post #7 would work, so if you guys don't mind, can you tell me if it is correct?

Many thanks guys.

---

Well, assuming somebody at some point has written a class called Quaternion, that has a *= operator and a normalise function that do what they say on the tin.

Thank you both again for helping me.

What I meant by what type of parameters to pass to glRotated is that I know the function looks like glRotate(angle, x, y, z), what I meant to ask is that how do I get the information of 'angle', 'x', 'y' and 'z' out of the orientation quaternion?

Is it as simple as accessing its four elements in order? i.e. orientation.w, orentation.x etc.

Quote:

---

Originally Posted by GOBLIN-85

Thank you both again for helping me.

What I meant by what type of parameters to pass to glRotated is that I know the function looks like glRotate(angle, x, y, z), what I meant to ask is that how do I get the information of 'angle', 'x', 'y' and 'z' out of the orientation quaternion?

Is it as simple as accessing its four elements in order? i.e. orientation.w, orentation.x etc.

---

Well ... yes. A quaternion is an angle and an axis, while glRotate expects an angle and an axis.

I just think you should have done some more thinking about glPushMatrix(), glPopMatrix(), and glGetFloatv() -- which with the last one you can extract the current values of the matrix -- before some hoodwinking hooligan got you onto this 19th century math voyage. Which I'm sure it is interesting, but I will not be riding in your spaceship even if you let me (no offense).

Here goes another problem.

I have something like:

Code:

---

//if 'a' key is hold.
if(aHold)
{
                Quaternion temp = Quaternion(30, 0, -1, 0);
                player->ori *= temp;
                player->ori.normalise();
}

---

This bit does the rotation, then in the display method, or rather, draw mathod, the code looks like:

Code:

---

void spaceship::draw()
{
        if (alive)
        {
                glPushMatrix();
                        glTranslated(position.x, position.y, position.z);
                        glRotated(ori.r, ori.i, ori.j, ori.k);
                        glCallList(starfighter);
                        glCallList(engine_glow);
                glPopMatrix();
        }
}

---

what happens now is that when I hold 'a' key, the ship will rotate to the left, however after a small amount of ratation, it resets to the original orientation. Then it start rotating to the left again. This keeps going very fast and looks like vibration.

Any idea where I might have done wrong?

Are you sure you want 30 degrees (assuming your quaternions are in degrees, which I shouldn't assume)? That means that in 12 frames your spaceship goes all the way around, and 12 frames is approximately 1/5 of a second.

I'm using a quaternion class found on the web. It's like this:

Code:

---

#ifndef QUATERNION_H
#define QUATERNION_H

#include <math.h>
#include "physics.h"

class Quaternion
{
        public:
                union {
                        struct {
                                double r;

                                double i;

                                double j;

                                double k;
                        };

                        double data[4];
                };

                /**
                * The default constructor creates a quaternion representing
                * a zero rotation.
                */
                Quaternion() : r(1), i(0), j(0), k(0) {}

               
                Quaternion(const double r, const double i, const double j, const double k)
                        : r(r), i(i), j(j), k(k)
                {
                }
           

                void normalise()
                {
                        double d = r*r+i*i+j*j+k*k;

                        // Check for zero length quaternion, and use the no-rotation
                        // quaternion in that case.
                        if (d == 0) {
                                r = 1;
                                return;
                        }

                        d = ((double)1.0)/sqrt(d);
                        r *= d;
                        i *= d;
                        j *= d;
                        k *= d;
                }

                void operator *=(const Quaternion &multiplier)
                {
                        Quaternion q = *this;
                        r = q.r*multiplier.r - q.i*multiplier.i -
                                q.j*multiplier.j - q.k*multiplier.k;
                        i = q.r*multiplier.i + q.i*multiplier.r +
                                q.j*multiplier.k - q.k*multiplier.j;
                        j = q.r*multiplier.j + q.j*multiplier.r +
                                q.k*multiplier.i - q.i*multiplier.k;
                        k = q.r*multiplier.k + q.k*multiplier.r +
                                q.i*multiplier.j - q.j*multiplier.i;
                }


                void addScaledVector(const Vector3& vector, double scale)
                {
                        Quaternion q(0,
                                vector.x * scale,
                                vector.y * scale,
                                vector.z * scale);
                        q *= *this;
                        r += q.r * ((double)0.5);
                        i += q.i * ((double)0.5);
                        j += q.j * ((double)0.5);
                        k += q.k * ((double)0.5);
                }

                void rotateByVector(const Vector3& vector)
                {
                        Quaternion q(0, vector.x, vector.y, vector.z);
                        (*this) *= q;
                }
};

#endif

---

I'm not sure if degree or radian should be used here. Although either way I do agree that the value I put in there was way to big. However, in what format would you suggest me to represent the angle and could you give me an example?

Okay I got it to work. The idea here is to use a 6 element float array to represent the current state of an object, which I'm using a cube (eight sides!), not a spaceship:

Code:

---

typedef struct {
        float x;
        float y;
        float z;
        float xR;
        float yR;
        float zR;
} Thing;

Thing Cube={0.0f}  /* we begin at the origin */

---

I have two functions to deal with Cube, both of which get called in my glutDisplayFunc() if you want to learn with glut. Anyway, the second one builds a cube, bells, whistles, textures, rocket launchers, what have you, using the Cube coordinates. The first one is what's important here, because it controls the position of the cube:

Code:

---

void movecube () {    /* think borg ;) */
        float trix[16];
        glPushMatrix(); /* reserve current state */

        glTranslatef(Cube.x,Cube.y,Cube.z);      /* move to  */
        glRotatef(Cube.xR, 1.0f, 0.0f, 0.0f);    /* where we  */
        glRotatef(Cube.yR, 0.0f, 1.0f, 0.0f);    /* should be */
        glRotatef(Cube.zR, 0.0f, 0.0f, 1.0f);      /* INCLUDE ROTATION */

        glTranslatef(0.0f,0.0f,0.5f);  /* now move FORWARD slowly... */

        glGetFloatv(GL_MODELVIEW_MATRIX,trix);
        Cube.x=trix[12];        /* this saves the new position of the Cube */
        Cube.y=trix[13];
        Cube.z=trix[14];

        glPopMatrix();  /* restore state (IMPORTANT) */
}

---

Like I said, this gets called before the routine which uses the Cube.elements to draw the cube in the right place.

You control the xR, yR, zR with arrow keys + pgup/pgdown (glut handles this mostly). You have no choice about the acceleration, it is constant (nice simple demo), but it is relative to the cube; ie, it always moves front face forward, so you can steer it around all three dimensions (and notice, the forward is always because of a Z translation, just what you wanted!!).

So it works fine. I can keep it spiralling around the viewport perpetually, but of course steering an object you are watching from the ground is tricky (get the camera to follow: next step). Sorry there are no quaternions. :) :) :)

ps. That is some crazy C++ tish found by the OP! I thot it was supposed to be better! "Object oriented" AHAHAHA!!

hey MK27! That's a nice example you just wrote. I actually thought about similar thing. But a little different.

I had a vector to store ship position, and had another vector to store rotation. while I press 'a', it goes:

Code:

---

        if(aHold)
        {
                player->rotation.y+=1;
        }

---

then in the draw method of the player class, I had:

Code:

---

void spaceship::draw()
{
        if (alive)
        {
                glPushMatrix();
                        glTranslated(position.x, position.y, position.z);
                        glRotated(rotation.x, 1, 0, 0);
                        glRotated(rotation.y, 0, 1, 0);
                        glRotated(rotation.z, 0, 0, 1);

                        glCallList(spaceship);
                        glCallList(engine);
                glPopMatrix();
        }
}

---

Is it similiar to yours? What I failed to do was set the camera to follow the ship. Now I actually prefer your suggestion as it is more understandable to me. But could you tell me how can I set the camera to follow the ship? I have something like:

Code:

---

                        glPushMatrix();

                                gluLookAt(0, 20, -80,                                                                               
                                                        0, 0, 1,                                                                               
                                                                0, 1, 0);                                                                       

                               

                                glRotated(player->getRotation().x, -1, 0, 0);
                                glRotated(player->getRotation().y, 0, -1, 0);
                                glRotated(player->getRotation().z, 0, 0, -1);
                               
                       
                                glTranslated(        0 - player->getPosition().x,
                                                                0 - player->getPosition().y,
                                                                0 - player->getPosition().z);
                             
                                  //------------draw scene---------------//

---

But it does not quite 'follow' the ship. As after few key presses, the ship can eventually face the screen which is something i dont want.

I would just put glutLookAt in the renderscene() function or What-You-Call-It after you have both the camera and Cube position:

Code:

---

        update_cam();
        arrangelamp();
        movecube();
        gluLookAt(Cam.x,Cam.y,Cam.z,Cube.x,Cube.y,Cube.z,0.0f,1.0f,0.0f);

---

Which my camera is still stationary, but having it follow the cube is sweet; I have the lighting set up and a point to represent it so I can actually fly the cube directly into the light, it looks very nice. gluLookAt is part of the main API, too, not GLUT (so it needn't be a crutch).

"GLUT" itself sort of restricts the form of the functions you can use which I resented at first, my prologue list was like a string of void ()s, but now I am beginning to think it was all (openGL) intended to work in a very streamlined way, lots of simple parts. A function call with little to no stack (key use of globals) is, I believe (perhaps wrongly?) very low stress on the all important processor.

Quote:

---

As after few key presses, the ship can eventually face the screen which is something i dont want.

---

Ah! Yeah I'm getting tired, actually, I've been here all day. But if I do find another simple way to finish this one I'll post it here sometime this week...

ps. the last time I thought of trying, the camera starts a few units behind the ship, and it's position is always determined that way (as a negative value on the z axis of the ship object). Don't even bother with the xR, yR, and zR of the camera Thing, because gluLookAt settles it.

Quote:

---

Originally Posted by MK27

ps. the last time I thought of trying, the camera starts a few units behind the ship, and it's position is always determined that way (as a negative value on the z axis of the ship object). Don't even bother with the xR, yR, and zR of the camera Thing, because gluLookAt settles it.

---

This idea does work, altho you do need to "bother with" and match the rotation as well as using gluLookAt.

Code:

---

void update_cam() {
        float trix[16];
        glLoadIdentity();
        glPushMatrix();
   
        glTranslatef(Cube.x,Cube.y,Cube.z);    //match cube 
        glRotatef(Cube.xR, 1.0f, 0.0f, 0.0f); 
        glRotatef(Cube.yR, 0.0f, 1.0f, 0.0f);   
        glRotatef(Cube.zR, 0.0f, 0.0f, 1.0f); 

        glTranslatef(0.0f,0.0f,-50.0f);    // behind cube
 
        glGetFloatv(GL_MODELVIEW_MATRIX,trix);
        Cam.x=trix[12];        // save position of cam
        Cam.y=trix[13];
        Cam.z=trix[14];
        glPopMatrix(); 
}

---

Obviously movecube() should be called before updatecam() now.

One significant factor is that the z rotation of the Cube has to occur before the other rotations in order to "bank correctly", so the relevant part movecube() should look like this:

Code:

---

        glTranslatef(Cube.x,Cube.y,Cube.z);
        glRotatef(Cube.zR, 0.0f, 0.0f, 1.0f);  /*  z first to allow banking */
        glRotatef(Cube.xR, 1.0f, 0.0f, 0.0f);
        glRotatef(Cube.yR, 0.0f, 1.0f, 0.0f);

---

Whilst the camera determination needs to be in the proper order. Not including the rotations in updatecam() will cause the object to turn toward the camera, as the OP complained about, so that you are now going backward.

If you want to follow the ship with the camera or do a 'chase camera' it's a simple matter of setting your camera's up, look and right vectors to the ship's up, look, and right. Then translate along the negative look vector of the ship for the desired zoom distance and this is where you place your camera. As long as the up, look, and right vectors match between camera and ship you can roll, pitch, and yaw the ship however you want and the camera will stay fixed right behind the ship.

I find it convenient to also translate a bit along the ship's up vector to put the camera above and behind the ship rather than just directly behind it.

If you want to get more complex and have the camera swing back and forth you will need quaternions as well as some simple spring mechanics to make it look right.

Hooke's law for springs is:

F = -kx

Where:
F = force in newton/meters
k = spring constant in newton/meters
x = distance between equilibrium of the spring and the stretch point of the spring (the stretch of the spring in meters)

Notice this does not take into account friction which is really what makes a spring lose it's force over time. You will need another equation that will tell you how far the spring can stretch. At that point you can then compute the return force of the spring or the magnitude of the force that is causing the spring to retract by using the above formula.