How compute new camera parameters given a velocity vector?

Question

My goal is to update camera parameters given a velocity vector so that the camera points in the direction of the velocity vector. How should one compute the update matrix for the camera parameters?

Answer 1

The velocity vector becomes your forward vector, just normalize it. The up direction doesn't change, use whatever version up the camera usually uses. The last vector (call it the "right hand" vector) is the cross product of up, and forward. Then, do a second cross with the forward vector and the right hand vector to guarantee an orthonormal basis.

The last bit needed is the translation which will have to come from somewhere.

The exact ordering of all the operations is going to depend on the setup you are using. Is up direction y or z ect.

Once the matrix if formed, find its inverse. (Since you went through the trouble of making sure it is orthonormal, the inverse is equivalent to the transpose.)

This is the new view matrix.

Edit: When dealing with Azimuth and Elevation you can extract the angles from a vector using the geometric asin and acos functions. For example:

    vec3d fwd = target_point - camera_point; // generate a vector somehow
    fwd = normalize(fwd); // normalize it
    float azimuth = acos( fwd.x );
    float elevation = asin( fwd.y );  // extract angles
    if( fwd.z < 0 ) { elevation = -elevation; } // fix quadrant based sgn(z)

The above assumes that z is the up axis, and that azimuth/elevation are given in radians.

Now that the look direction is decided. Save it off to the side, and begin turning the camera. A good approach to turning the camera is to have a "radians per a second" turn rate. Get the time delta between updates from the system. And use those values to compute how much the camera should turn each frame just by computing the total number of radians that is needed for each direction.

    float time_delta_in_seconds = elapsed_seconds_since_last_frame();
    const float radians_per_second = 0.1; // slowish
    float turn_amount = time_delta_in_seconds * radians_per_second;
    float turn_amount = min(radians_to_turn, turn_amount); // don't overlook
    radians_to_turn -= turn_amount; // update  - converges on zero

So each frame:

1. update the velocity vector
2. compute the new camera settings but don't use them, save them
3. compute your camera turn amount and update the camera with the new values

Make the 3 steps independent and the camera will just keep turning, chasing the velocity vector.

Handling user intervention seems self evident, if the user turns the camera disable the auto camera turning. If you want the camera to start turning after some preset amount of time, then just set a timer that enables auto turning and reset it every time the user moves the camera.

While this isn't the best system for auto camera following, it works and should (hopefully) get you going. The camera turning will be very mechanical since the turn rate is fixed. But once its all set its not to hard to add acceleration using the same ideas.

It just occurred to me that this is like 3 separate questions in one, really these should have been asked separately. At any rate, this should help some I hope.