No nosso último programa, nós imprimimos na tela um triângulo nas seguintes posições:

Ponto 1
x = 0.0f
y = 1.0f

Ponto 2
x = -1.0f
y = -1.0f

Ponto 3
x =  1.0f
y = -1.0f

Até aqui tudo bem... o problema é que quando o triângulo foi impresso, ele ocupou a tela toda!

Mais como pode isso??
Até antes de iniciarmos os estudos sobre gráficos 3D, os limites da tela eram em pixels.
Geralmente o limite de x era 640 e de y era 480.

Então como pode 1.0f equivaler 640 e ao mesmo tempo 480 ??

Bom, o que acontece é que em OpenGL as representações gráficas são geradas automaticamente a partir de conjuntos de dados, e geralmente, esses conjuntos são representados por valores que variam de 0 até 1.

Com certeza é bem estranho esse tipo de definição...
demorou mais eu achei a explicação para isso, que por sinal é bem fácil.

Como a computação gráfica evoluiu muito nos últimos anos, foi necessário desenvolver aplicações que possam rodar em diferentes plataformas.
Com o tempo foram criadas várias placas aceleradores 3D ( famosas placas como GForce e ATI Radeons da vida ) e para cada uma delas era necessário escrever um código próprio, o que tornava o desenvolvimento ainda mais complicado.

A partir disso, foi necessário desenvolver um padrão para programas gráficos que iria facilitar escrever códigos para diferentes tipos de hardware.

Muitos e muitos padrões foram criados, mais o mais popular hoje em dia é o OpenGL, justamente a que estamos estudando.. ( isso foi pura coincidência, eu não tinha a mínima idéia disto antes de escrever isso hehehehe ).

Os hardwares 3D usam uma malha retangular de posições endereçáveis - a qual é denominada "retângulo de visualização".
Todo hardwares de entrada e saída de gráficos possuí uma resolução total, que é o número de pontos ( ou pixels ) horizontais e verticais que ele pode apagar ou acender.

Para trabalhar com OpenGL precisamos definir sistemas de coordenadas para quantificar os dados sendo manipulados. Os pixels são endereçados por dois números inteiros que dão suas coordenadas horizontal e vertical, X, e Y.

No "retângulo de visualização" o pixel endereçado como (0,0) está geralmente no canto inferior esquerdo.
Neste mesmo "retângulo de visualização" o valor dcx+1 dá o número da coluna, e dcy+1 dá o número da linha do pixel endereçado.

As coordenadas (dcx,dcy) são chamadas de coordenadas do dispositivo, e podem assumir apenas valores inteiros.

Coordenadas do dispositivo podem variar bastante para diferentes equipamentos, o que levou à utilização de coordenadas normalizadas do dispositivo (NDC - normalized device coordinates), para efeito de padronização (ndcx,ndcy).

A vantagem da utilização de NDCs é que padrões gráficos podem ser discutidos usando um sistema de coordenadas independente de dispositivos gráficos específicos.

Então.. voltando a nossa primeira pergunta, você já deve ter entendido por que que, 1.0f pode ser 640 ou 480.
Todos os dados gráficos precisam ser transformados do sistema de coordenadas independente para o sistema de coordenadas do dispositivo no momento de visualização, ou seja, do mapeamento de NDCs (reais) para as coordenadas do dispositivo (inteiros, X e Y).

Para isto, existe a seguinte fórmula:

ndc do X = ( x - "X inicial" ) / ( "X total" - "X inicial" );

ndc do Y = ( y - "Y inicial " ) / ( "Y total " - "Y inicial " );

Onde inicial é o valor mínimo ( de X e Y ) e o Total é o Valor Máximo ( de X e Y ).

É isso..

Agora vamos brincar um pouco para entender melhor essas coordenadas, já que é praticando que se aprende.
Vamos montar um programa para testar as coordenadas:

GLfloat i = 0.0f;
glBegin(GL_POINTS);
for ( i = 1; i<=30; i++ )
{
     glVertex3f( i/10, 0.0f, 0.0f);
     glVertex3f( 0.0f, i/100, 0.0f);
}
glEnd();

O resultado vai ser este:

Você pode executar o código acima colocando na função de display do glut ou antes de dar um flip na tela com AllegroGL.

O programa acima, imprime vários pontos distantes na horizontal.
Isso acontece por que fazemos um for de 1 até 10, e para cada ponto dividimos a posição do ponto por 10.

Desta forma:

1 / 10 = 0,1
2 / 10 = 0,2
3 / 10 = 0,3

Os pontos ficam um pouco longe uns dos outros.

O programa acima também imprime vários pontos bem próximos uns dos outros na vertical.
Isso acontece por que fazemos um for de 1 até 10, e para cada ponto dividimos a posição do ponto por 100.

Desta forma:

1 / 10 = 0,01
2 / 10 = 0,02
3 / 10 = 0,03

Fazendo com que os pontos fiquem uns mais próximos dos outros.

Acredito que com esse exemplo você tenha entendido melhor o sistema de coordenadas da OpenGL.