Camera Orbital com OpenGL

Estou implementando uma câmera orbital ao redor de um desenho feito no centro do sistema de referencial universal, estou usando o openGL e a biblioteca glm; eu consegui fazer a câmera se aproximar do objeto quando aperto W, porém a aproximação adequada só acontece quando pressiono W e mexo no tamanho da janela, pois se eu não fizer esse ritual a imagem fica toda desalinhada.

Acredito que seja algo relacionado a atualização da gluLookAt() estou usando glutPostRedisplay() após atualizar a posição da câmera porém mesmo assim o bug continua, alguém já passou pelo mesmo problema, ou faz ideia de como eu possa resolver.

Aqui está o código com as funções responsáveis por alterar o posicionamento da câmera, atualmente apenas a função de avançar está sendo desenvolvida:

vec3 olho;
vec3 alvo = {0, 0, 0};
float _raioDaCamera=30;
float _phi = 90;
float _teta = 90;


float Sen (float angulo){
    return sin(angulo*M_PI/180);
}

float Cos (float angulo){
    return cos(angulo*M_PI/180);
}

vec3 convertePCartesiano(float raioCamera, float phi, float teta){


    float x = raioCamera*Sen(phi)*Sen(teta);  //x
    float y = raioCamera*Cos(phi); //y
    float z = raioCamera*Sen(phi)*Cos(teta);  //z

    if(x > 0 && x < 0.0001) x = 0;
    if(y > 0 && y < 0.0001) y = 0;
    if(z > 0 && z < 0.0001) z = 0;

    vec3 vetor (x, y, z);
    return vetor;
}

void updateCamera (float raioCamera, float phi, float teta){
    olho = convertePCartesiano(raioCamera, phi, teta);
    alvo = (-1.0f) * olho;

    gluLookAt(olho.x, olho.y, olho.z, alvo.x, alvo.y, alvo.z, 0, 1, 0);
}

vec3 normalize(const vec3 &vetor){
   float norma = sqrt(pow(vetor.x, 2) + pow(vetor.y, 2) + pow(vetor.z, 2));

   if(norma > 0)
        return vec3(vetor.x/norma, vetor.y/norma, vetor.z/norma);
   return vec3(0, 0, 0);
}

float magnitude (vec3 &vetor){
    return sqrt(pow(vetor.x, 2) + pow(vetor.y, 2) + pow(vetor.z, 2));
}

void avanca(){
    vec3 direcao = alvo;

    direcao = normalize(direcao);
    vec3 velocidade = direcao * (0.25f);
    olho = olho + velocidade;

    _raioDaCamera = magnitude(olho);

    updateCamera(_raioDaCamera, _phi, _teta);
}

void eventoDeTeclado(unsigned char key, int x, int y){
    switch(key){
        case 'q':
        case 'Q':
            exit(0);
            break;
        case '+':
            if(raio < 11.12)
                raio += 0.12;
            break;
        case '-':
            if(raio > 6.32)
                raio -= 0.12;
            break;
        case 'w':
        case 'W':
		avanca();
            break;
        default:
            break;
    }
    glutPostRedisplay();
}

É difícil ajudar com um código parcial, onde está declarada a variável raio?

De qualquer forma, convertePCartesiano me indica que você pode estar fazendo algo errado, você não deveria precisar converter um vetor para um plano ortogonal.

O ideal seria você sempre trabalhar num plano ortogonal e deixar apenas para fazer a transformação para uma matriz de projeção do seu agrado (perspectiva, paralela, etc, que leve as dimensões da sua janela em consideração) quando for renderizar o frame.