How to program a rotation system like in a flight simulator in java?

Question

I try to write a rotation system for a theoratical flight device. My main problem is that I practically nearly never rotate around the axes of the coordinate system, but around the axes of the vehicle (pitch, roll, jaw). An object rolled around it's own z axis changes a following pitch rotation around its x axis.

My furthest idea is to use a position vector and three direction vectors of the vehicle which describe the positions {1,0,0},{0,1,0},{0,0,1}. I guess this vectors could somehow be used to store the axes of the object. When rotating the vehicle I would rotate two of this points around the axis symbolised by the the remaining point. As vectors I use javafx.geometry.Point3D.

So far I have this code for my start rotation which don't respects the vehicles rotation which it gets over time. Further is rotates a JavaFX shape which is also not my goal. (I want to have and transform raw coordinates for other uses than just drawing them)

final Point3D isFacing = new Point3D(0, 0, 1).normalize();
final Point3D shouldFace = position.subtract(goalDirection).normalize();

final double rotationAngle = Math.toDegrees(Math.acos(isFacing.dotProduct(shouldFace)));

final Point3D rotationAxis = isFacing.crossProduct(shouldFace).normalize();

Rotate rotate = new Rotate(rotationAngle, rotationAxis);
model.getTransforms().addAll(rotate);

How to store the parameters? How to compute the rotations?

Answer 1

If this is the first time you've tried something like this, try doing something very basic and simple first.

Follow these steps:

• Try defining a cuboid, a List of 8 3D points around an origin.
• Write some code to vector-render it in 3D perspective, drawing the 12 lines between the edge points, where each point is (X/(Z + dist)*scale, Y/(Z+dist)*scale), where dist is some amount to push the object out in your view, and scale is a magnification factor.
• Now try rotating in the roll axis: for each point, calculate X1 = X*cos(roll) + Y*sin(roll) and Y1 = Y*cos(roll) - X*sin(roll)
  • this will give you a new set of points - make sure you can draw these instead. Your cuboid should appear tilted.
  • what we've just done is open out a matrix multiplication by a rotation transformation matrix.
  • I'm assuming you are looking down the Z-axis positive, which means that rolling is rotation around Z, in the X-Y plane.
• Now try another rotation around the pitch (X) axis, rotating in the Y-Z plane: Y2 = Y1*cos(pitch) + Z*sin(pitch) and Z1 = Z*cos(pitch) - Y1*sin(pitch)
  • and render that: the shape should be nodding at you.
• And finally: another rotation around the yaw (Y) axis, rotating in the X-Z plane: X2 = X1*cos(yaw) + Z1*sin(yaw) and Z2 = Z1*cos(yaw) - X1*sin(yaw)

You can now point the object anywhere you like. You are explicitly applying the rotations in order: roll it, then pitch it, and then yaw/orientate it. Once you understand the steps of what you are doing you can try writing this out as 3x3 matrices - you'll see that you can premultiply a single matrix to perform the transform for arbitrary roll/pitch/yaw.

And as you've observed, applying those transforms in a different order will change the outcome, but the matrix multiplication isn't commutative: changing the order messes it up.

Once you've got those basics firmly in your head, go off and read about more of the principles and practice. A good goal is to be able to draw a shape and spin it, translate it around your viewpoint, slide it left/right up/down. There is a clever way of using a 4x4 matrix, which captures the translation vector directly, see How does 4x4 matrix work in 3d graphic?.

But get a sinple thing working first, where you understand every single part. Then more advanced approaches, quaternions mentioned above etc, won't seem so daunting.