A rotação da câmara utilizada para a projecção em perspectiva

votos
0

Eu apenas comecei a brincar com OpenGL para renderizar uma série de estrutura de cada compreendendo um número de polígono. Basicamente eu quero executar o equivalente de definir uma câmera em (0,0, z) no mundo (estrutura) coordena e girá-lo sobre os x, yez-eixos dos eixos mundo (nessa ordem!) Para renderizar uma vista de cada estrutura (tal como o entendo-lo prática comum fazer uso da matriz câmara inversa). Assim como eu entendo que eu preciso para traduzir (para ie origem mundo (0,0, -z)) * rotateZ rotateY rotateX * traduzir (redefinir origem mundo veja abaixo)

Então eu acho que eu preciso de algo como:

//Called when the window is resized
void handleResize(int w, int h) {
    glViewport(0, 0, w, h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(9.148, (double)w / (double)h, 800.0, 1500.0);
}

float _Zangle = 10.0f; 
float _cameraAngle = 90.0f;

//Draws the 3D scene
void drawScene() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW); //Switch to the drawing perspective
    glLoadIdentity(); //Reset the drawing perspective

    glTranslatef(0.0f, 0.0f, -z); //Move forward Z (mm) units
    glRotatef(-_Zangle, 0.0f, 0.0f, 1.0f); //Rotate camera about the z-axis
    glRotatef(-_cameraAngle, 0.0f, 1.0f, 0.0f); //Rotate the camera by camera_angle about y-axis
    glRotatef (90.0f,1.0f,0.0f,0.0f); // rotate camera by 90 degrees about x-axis
    glTranslatef(-11.0f,189.0f,51.0f); //re-define origin of world coordinates to be (11,-189,-51) - applied to all polygon vertices

glPushMatrix(); //Save the transformations performed thus far

glBegin(GL_POLYGON);


    glVertex3f(4.91892,-225.978,-50.0009);
        glVertex3f(5.73534,-225.978,-50.0009);
        glVertex3f(6.55174,-225.978,-50.0009);
        glVertex3f(7.36816,-225.978,-50.0009);
        .......// etc
glEnd();
glPopMatrix();

No entanto, quando eu compilar e executar este o _angle e _cameraAngle parecem ser revertida ou seja _angle parece rodar em torno do eixo Y (vertical) da janela de visualização e _cameraAngle cerca de eixo z (em plano do visor)? O que estou fazendo de errado?

Obrigado por tomar o tempo para ler este

Publicado 22/12/2009 em 14:19
fonte usuário
Em outras línguas...                            


5 respostas

votos
5

A resposta curta é: Use gluLookAt (). Esta função utilitário cria a matriz de visualização adequada.

A resposta mais longa é que cada chamada transformação OpenGL leva a matriz atual e multiplica-o por uma matriz construído para realizar a transformação. Ao chamar uma série de função de transformação OpenGL-lo a construir uma matriz de transformação que irá aplicar a combinação de transformações. Efetivamente, a matriz será M = M1 * M2 * M3. . . Matematicamente, as transformações são aplicadas da direita para a esquerda na equação acima.

Seu código não mover a câmera. Ele permanece na origem, e olha para baixo do eixo z negativo. Os seus transformações mover tudo no espaço do modelo para (11, -189, -51), gira tudo 90 graus sobre o eixo x, tudo gira 90 graus em torno do eixo Y, roda em tudo o que 10 graus em torno do eixo Z, em seguida, se traduz tudo -zao longo do eixo z.

EDIT: Mais informações

Estou um pouco confuso sobre o que você quer realizar, mas eu acho que você quer ter elementos na origem, e tem o olhar câmera para esses elementos. As coordenadas do olho estaria onde você quer a câmera, e as coordenadas do centro estaria onde você deseja que os objetos a ser. Eu usaria um pouco de trigonometria para calcular a posição da câmera, e apontá-lo na origem.

Neste tipo de situação eu costumo manter o controle de posição da câmera usando longitude, latitude e altitude centrada na origem. Calculando x, y, z coordenadas para o olho é simplyx = cos ELV * (lat) * sen (lon), Y = ELV * sen (LAT), z = cos ELV * (LAT) * cos (latitude).

Meu chamado gluLookAt seria gluLookAt(x, y, z, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0);

Você poderia girar para cima na câmara, alterando os últimos três coordenadas para gluLookAt.

Respondeu 22/12/2009 em 14:45
fonte usuário

votos
1

O eixo z é proveniente do centro do monitor em você. Então, girando em torno do eixo z deve fazer a rotação da câmera no lugar (como uma rotação 2D apenas no plano xy). Eu não posso dizer, mas é que o que está acontecendo aqui?

Respondeu 22/12/2009 em 14:22
fonte usuário

votos
0

Eu acho que você está misturando eixos de seu mundo com eixos da câmera,

GLRotatef só usa eixos da câmera, eles não são o mesmo que o seu mundo eixos uma vez que a câmara for rodada.

Respondeu 22/12/2009 em 15:53
fonte usuário

votos
0

Resposta curta: Boa dica

resposta mais longa: Sim, a ordem de multiplicação de matrizes é claro ... é isso que eu quis dizer com matriz de câmera inversa para indicar movendo todo o mundo coordena das estruturas para as coordenadas da câmera (daí o uso da "câmera" em meus comentários ;-)) em vez de realmente a tradução e rotação da câmara para as coordenadas globais.

Então, se eu ler nas entrelinhas corretamente você sugere algo como:

void drawScene() {
    glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

glMatrixMode(GL_MODELVIEW); //Switch to the drawing perspective
    glLoadIdentity(); //Reset the drawing perspective
gluLookAt(0.0,0.0,z,11.0,-189.0,-51.0,0.0,1.0,0.0); //eye(0,0,z) look at re-defined world origin(11,-189,-51) and up(0.0,1.0,0.0)

    glRotatef(-_Zangle, 0.0f, 0.0f, 1.0f); //Rotate "camera" (actually structures) about the z-axis
    glRotatef(-_cameraAngle, 0.0f, 1.0f, 0.0f); //Rotate the "camera" (actually structures!) by camera_angle about y-axis
    glRotatef (90.0f,1.0f,0.0f,0.0f); // rotate "camera" (actually structures) by 90 degrees about x-axis


glPushMatrix();

Ou ainda estou faltando alguma coisa?

Respondeu 22/12/2009 em 15:11
fonte usuário

votos
0

É possível que você está encontrando Gimbal bloqueio . Tente remover uma das rotações e ver se as coisas funcionam do jeito que deveriam.

Embora seja verdade que você não pode realmente mover a câmera em OpenGL, você pode simular o movimento da câmera, movendo todo o resto. É por isso que você ouve sobre a matriz de câmera inversa. Em vez de mover a câmera (0, 0, 10), podemos mover tudo no mundo por (0, 0, -10). Se você expandir-los um em matrizes, você vai achar que eles são inversos um do outro.

Notei também que, dado o código apresentado, você não precisa de os glPushMatrix()/ glPopMatrix()as chamadas. Talvez haja código que você não demonstraram que os obriga.

Finalmente, você pode dar uma ideia do que é que você está tentando processar? rotações de depuração pode ser difícil sem algum contexto.

Respondeu 22/12/2009 em 15:05
fonte usuário

Cookies help us deliver our services. By using our services, you agree to our use of cookies. Learn more