OpenGL float precision makes unexpected differece

Question

I have a function which rotates the camera around the player by yaw and pitch angles.

void Camera::updateVectors() {
    GLfloat radius = glm::length(center - position);
    position.x = cos(glm::radians(this->yaw)) * cos(glm::radians(this->pitch));
    position.y = sin(glm::radians(this->pitch));
    position.z = sin(glm::radians(this->yaw)) * cos(glm::radians(this->pitch));
    position *= radius;
    this->front = glm::normalize(center - position);
    this->right = glm::normalize(glm::cross(this->front, this->worldUp));
    this->up = glm::normalize(glm::cross(this->right, this->front));
    lookAt = glm::lookAt(this->position, this->position + this->front, this->up);
}

When I move the player the camera should moves with it by adding a translation vector to both the center and position of the camera:

void Camera::Transform(glm::vec3& t) {
    this->position += t;
    this->center += t;
}

Vefore moving the player the camera rotation works fine and the player movement also works fine but once I try to rotate the camera after player moving it start to change position unexpected.

After making some debugging I noticed that the radius which Is calculated at first line which is the distance between center and position of the camera like 49.888889 or 50.000079 and due to the initialized values it should be 50.0, this very small difference makes the result unexpected at all. so how could I treat this float precision or is there a bug in my code or calculations.

Edit: position the player depends on its yaw and pitch and update the center of the camera

GLfloat velocity = this->movementSpeed * deltaTime;
if (direction == FORWARD) {
    glm::vec3 t = glm::vec3(sin(glm::radians(yaw)), sin(glm::radians(pitch)), cos(glm::radians(yaw))) * velocity;
    matrix = glm::translate(matrix, t);
    for (GLuint i = 0; i < this->m_Entries.size(); i++) {
        this->m_Entries[i].setModelMatrix(matrix);
    }
    glm::vec3 f(matrix[2][0], matrix[2][1], matrix[2][2]);
    f *= velocity;
    scene->getDefCamera()->Transform(f);
}
if (direction == BACKWARD) {
    glm::vec3 t = glm::vec3(sin(glm::radians(yaw)), 0.0, cos(glm::radians(yaw))) * velocity;
    matrix = glm::translate(matrix, -t);
    for (GLuint i = 0; i < this->m_Entries.size(); i++) {
        this->m_Entries[i].setModelMatrix(matrix);
    }
    glm::vec3 f(matrix[2][0], matrix[2][1], matrix[2][2]);
    f *= velocity;
    f = -f;
    scene->getDefCamera()->Transform(f);
}

lookAt = glm::lookAt(this->position, this->position + this->front, this->up); this->front is a normalized vector. you are adding a small amount to your camera position i think. glm::lookat second argument should be the world position of the object, not sure ... — Paltoquet
put center instead of position+front it might help, don't know — Paltoquet
the second vector in lookAt function parameters is the view direction and center and position+front in the save vector direction so the result is the same — Mohamed
maybe the vectors change but the length could vary from different state where each of thoose states has a given value. If i were you i would not apply formula from spherical coordonates with pitch, yaw roll etc... And use glm::translate and glm::rotate with vec3 containing your angle and position. — Paltoquet
Please add your solution as a distinct answer, in the answer section, do not edit the question with solved see: Ask questions, get answers, no distractions — Petter Friberg

Nicol Bolas Nicol Bolas · Accepted Answer · 2017-07-04T14:41:23

The main problem here is that you're rotating based on a position that is moving. But rotations are based on the origin of the coordinate system. So when you move the position, the rotation is still being done relative to the origin.

Instead of having Transform offset the position, it should only offset the center. Indeed, storing position makes no sense; you compute the camera's position based on its current center point, the radius, and the angles of rotation. The radius is a property that should be stored, not computed.

OpenGL float precision makes unexpected differece

2 Answers