Estou tentando entender o sistema de coordenadas OpenGL. No entanto, alguns tutoriais dizem que o sistema de coordenadas padrão é canhoto (consulte http://www.c-sharpcorner.com/UploadFile/jeradus/OpenGLBasics11172005014307AM/OpenGLBasics.aspx ) e outros dizem que é destro (consulte http: // www .falloutsoftware.com / tutorials / gl / gl0.htm ). Qual é correto? Eu entendo que podemos transformar um ao outro por espelhamento, mas gostaria de saber as coordenadas padrão.

Existe alguma confusão aqui.

OpenGL é destro no espaço do objeto e no espaço do mundo.

Mas no espaço da janela (também conhecido como espaço da tela), de repente, somos canhotos .

Como isso aconteceu ?

A forma como passamos de destros para canhotos é uma entrada de escala z negativa nas matrizes de projeção glOrthoou glFrustum. Escalar z por -1 (enquanto deixa xey como estavam) tem o efeito de alterar a destreza do sistema de coordenadas.

Para glFrustum,

longe e perto devem ser positivos, com muito > perto . Diga distante = 1000 e próximo = 1. Então C = - (1001) / (999) = -1,002.

Veja aqui mais detalhes e diagramas.

De uma perspectiva ortográfica , glOrtho gera uma matriz como esta:

Aqui, esquerda , direita , inferior e superior são apenas as coordenadas para os planos de recorte vertical esquerdo , vertical direito , horizontal inferior , horizontal superior (resp) .

Os planos próximos e distantes , entretanto, são especificados de forma diferente . o próximo parâmetro é definido como

• Perto: a distância até o plano de corte de profundidade mais próximo. Esta distância é negativa se o avião estiver atrás do observador.

e longe:

• zFar a distância até o plano de corte de profundidade mais distante. Esta distância é negativa se o avião estiver atrás do observador.

Aqui temos um volume típico de visualização canônica

Como o multiplicador z é (-2 / (muito perto)), o sinal de menos escala z por -1 . Isso significa que "z" é virado para a esquerda durante a transformação da visualização, sem o conhecimento da maioria das pessoas, pois elas simplesmente funcionam no OpenGL como um sistema de coordenadas "destro".

Então, se você ligar

glOrthof(-1, 1, -1, 1, 10, -10) ; // near=10, FAR=-10,

Então o NEAR PLANE está 10 unidades à sua frente . Onde você está? Por que, na origem, com o eixo x à sua direita, o eixo y no topo da sua cabeça e seu nariz apontando para baixo do eixo z negativo (esse é o padrão "Por padrão, a câmera está situada na origem , aponta para baixo o eixo z negativo e tem um vetor superior de (0, 1, 0). " ). Portanto, o plano próximo está em z = -10. O plano distante está 10 unidades atrás de você, em z = + 10 .

Por padrão, o Normalized Device Coordinate é canhoto.

O glDepthRange é por padrão [0, 1] (próximo, distante) fazendo com que o eixo + z aponte para a tela e com + x para a direita e + y para cima, é um sistema para canhotos.

Alterar o intervalo de profundidade para [1, 0] tornará o sistema destro.

Citando uma resposta anterior de Nicol : (o tachado é meu trabalho, explicado abaixo)

Estou surpreso que ninguém tenha mencionado algo: o OpenGL também funciona em um sistema de coordenadas para canhotos. Pelo menos, isso acontece quando você está trabalhando com sombreadores e usa o intervalo de profundidade padrão.

Depois de descartar o pipeline de função fixa, você lida diretamente com o "espaço do clipe". A especificação OpenGL define o espaço do clipe como um sistema de coordenadas homogêneo 4D. Quando você segue as transformações por meio de coordenadas de dispositivo normalizadas e até o espaço da janela, você encontra isso.

O espaço da janela está no espaço dos pixels de uma janela. A origem está no canto esquerdo inferior, com + Y indo para cima e + X indo para a direita. Isso se parece muito com um sistema de coordenadas para destros. Mas e quanto ao Z?

O intervalo de profundidade padrão (glDepthRange) define o valor próximo de Z como 0 e o valor distante de Z como um . Portanto, o + Z está se afastando do visualizador.

Esse é um sistema de coordenadas para canhotos. Sim você podemude o teste de profundidade de GL_LESS para GL_GREATER ealtere glDepthRange de [0, 1] para [1, 0]. Mas o estado padrão do OpenGL é trabalhar em um sistema de coordenadas para canhotos . E nenhuma das transformações necessárias para chegar ao espaço da janela a partir do espaço do clipe nega o Z. Então, o espaço do clipe, a saída do sombreador de vértice (ou geometria) é um espaço para a mão esquerda (meio. É um espaço homogêneo 4D, então é difícil definir a destreza).

No pipeline de função fixa, todas as matrizes de projeção padrão (produzidas por glOrtho, glFrustum e similares) se transformam de um espaço para destros em um para canhotos . Eles invertem o significado de Z; basta verificar as matrizes que geram. No espaço ocular, + Z se move em direção ao visualizador; no espaço de pós-projeção, ele se afasta.

Suspeito que a Microsoft (e o GLide) simplesmente não se preocuparam em realizar a negação em suas matrizes de projeção.

Eu acertei uma parte, pois divergia de minhas descobertas.

Alterar DepthRange ou DepthFunc e usar ClearDepth (0) funciona, mas ao usar ambos eles cancelam um ao outro de volta para um sistema canhoto.

SOMENTE NDC

Você deve apenas notar que OpenGL só conhece NDC! e esse é um sistema de coordenadas para canhotos.

Não importa o sistema de coordenadas que você usa - sistema de coordenadas de eixo para canhotos ou destros - todos precisam ser espelhados para NDC. Se quiser, você pode lidar totalmente com o espaço-mundo como um sistema de coordenadas para canhotos.

Por que geralmente usamos o sistema de coordenadas para destros no espaço mundial?

Eu acho que é convencional. Simplesmente faz. Talvez ele apenas queira fazer uma distinção do DirectX.

O livro "WebGl Programming Guide" de Kouichi Matsuda gasta quase dez páginas em "WebGl / OpenGl: Left or Right Handed?"

De acordo com o livro:

• Na prática, a maioria das pessoas usa um sistema destro

• OpenGl na verdade é um sistema para canhotos internamente

• Internamente, mais profundamente, não é nenhum dos dois. No fundo, o OpenGl não se preocupa com o valor z. A ordem em que você desenha as coisas determina o que é desenhado no topo (desenhe um triângulo primeiro, depois um quad, o quad substitui o triângulo).

Não concordo totalmente com o "não é nenhum dos dois", mas essa é provavelmente uma questão filosófica de qualquer maneira.

Opengl é definitivamente canhoto. Você vê muitos tutoriais afirmando o oposto porque eles estão negando o valor z na matriz de projeção. Quando os vértices finais são calculados dentro do sombreador de vértice, ele converte os vértices que você passa do lado do cliente (coord à direita) para o canhoto, e os vértices são passados ​​para o sombreador de geometria e o sombreador de fragmento. Se você usar o sistema de coordenadas da mão direita no lado do cliente, Opengl não se importa. Ele conhece apenas o sistema de coordenadas normalizado, que é canhoto.

Edit: Se você não confia em mim, experimente em seu sombreador de vértice adicionando uma matriz de tradução e você poderá ver facilmente se Opengl é canhoto ou não.

Usando as funções de projeção e transformação integradas do OpenGL, observar os movimentos na tela segue as regras do sistema de coordenadas para destros . Por exemplo, se um objeto na frente de sua visualização for transladado na direção z positiva, o objeto se moverá em sua direção.

O buffer de profundidade é exatamente o oposto, e é aqui que as NDC (Normalized Device Coordinates) entram em jogo. Se passar GL_LESS para o glDepthFunc significa que os pixels serão desenhados quando estiverem mais próximos de você do que o que já está no buffer de profundidade, então os pixels são considerados como vivendo em um sistema de coordenadas para canhotos .

Há mais um sistema de coordenadas e essa é a janela de visualização! O sistema de coordenadas da janela de visualização é tal que + x aponta para a direita e + y aponta para baixo. Eu acho que neste ponto a lateralidade é discutível, já que estamos lidando apenas com x, y neste ponto.

Por último, gluLookAt sob o capô tem que negar o vetor de visualização. Uma vez que a matemática assume que um vetor está apontando em uma direção positiva em direção ao objeto que está olhando e uma câmera olha para baixo -z, o vetor de olhar deve ser negado para que se alinhe com a câmera.

Algo para mastigar. Não faz muito sentido chamar a direção z de um sistema de coordenadas para destros de vetor direto :). Acho que a Microsoft percebeu isso quando projetou o Direct3D.