使用方向向量和变换矩阵的OpenGL对象旋转

Question

I have a physics simulator which has a direction vector and I need to calculate the rotation of the object to follow it.

     Vec3f up_vector = Vec3f(0,1,0);
     Vec3f direction_vector  = directionVector(position, previous_position);
     Vec3f crossproduct = normaliseVector(Vec3f(up[0] * direction[0], up[1] * direction[1], up[2] * direction[2]));
      Vec3f crossproduct2 = normaliseVector(Vec3f(crossproduct[0] * direction_vector[0], crossproduct[1] * direction_vector[1], crossproduct[2] * direction_vector[2]));

        rotation = Matrix44f(
        { crossproduct[0], crossproduct[1], crossproduct[2], 0 },
        { crossproduct2[0], crossproduct2[1], crossproduct2[2], 0 },
        { direction_vector[0], direction_vector[1], direction_vector[2], 0 },
        { 0, 0, 0, 1 });

        glMultMatrixf(rotation);

The object seems to rotate in the right direction but is only drawn in one axis (looks like a 2D object and cant be seen from the x axis when at the origin). I don't know if this is more to do with how OpenGL works?

Answer 1

This doesn't look right. You have variables named crossproduct , but you're not calculating a cross product anywhere. I think this could fundamentally work if you replace your vector operations by cross products where the name indicates that they should be.

Also, it looks like you're partly not using the right variable names. For example, there are values assigned to up_vector and direction_vector , but then the calculations use up and direction .

Using your initial naming, this would become:

Vec3f up_vector = Vec3f(0,1,0);
Vec3f direction_vector  = directionVector(position, previous_position);
// Assuming that directionVector() returns a normalized vector.
Vec3f crossproduct = normaliseVector(crossProduct(up_vector, direction_vector));
Vec3f crossproduct2 = crossProduct(direction_vector, crossproduct);

Then build the matrix with those vectors as before. Of course this goes wrong if direction_vector is pointing exactly in the same direction as up_vector . To make this robust for all directions, you'll have to special case that.

In the above, crossProduct() is a standard cross product:

Vec3f crossProduct(const Vec3f& v1, const Vec3f& v2) {
    return Vec3f(v1.y * v2.z - v1.z * v2.y,
                 v1.z * v2.x - v1.x * v2.z,
                 v1.x * v2.y - v1.y * v2.x);
}