Ponto V!

Home OpenGL Sistemas de coordenadas
Vinícius Godoy de Mendonça
Sistemas de coordenadasImprimir
Escrito por Vinícius Godoy de Mendonça

Para desenhar qualquer objeto no espaço, é necessário descrevê-lo. E, para descrever um objeto, você necessita de referências, onde medidas se encontram numa escala válida. Normalmente, fora do OpenGL, descrevemos a posicionamento de pontos através da notação de linha/coluna. Embora essa notação seja adequada para o desenho de textos, ela está muito afastada da notação matemática, e acaba se tornando pouco prática para o desenho de figuras.

No OpenGL, assim como em praticamente todas as APIs 3D, você pode definir o seu próprio sistema de coordenadas. O sistema padrão, utilizado até agora, envolvia coordenadas de -1 até 1, tanto em x, y e z. O que fazia que as imagens ficassem lateralmente esticadas, já que a tela não é um quadrado e, logo, -1 até +1 em x é uma distância maior que -1 até +1 em y.

Nesse artigo, vamos aprender sobre como o OpenGL define o sistema de coordenadas, como definir o nosso próprio sistema e as diferentes formas de mapeamento de coordenadas.

Coordenadas cartesianas 2D


Além de diversos trabalhos de filosofia (e da criação da frase “Penso, logo existo.”), René Descartes (ou, Renatus Cartesius, em latim) foi também um matemático importante, e criou duas técnicas que conhecemos hoje como sistema cartesiano e geometria analítica. Se tivermos que atribuir um pai a computação gráfica, Descartes seria realmente um ótimo candidato à vaga.

A localização de cada ponto cartesiano é formada de um par de números, um no eixo x e outro no eixo y, chamados coordenadas. A coordenada x mede uma distância na direção horizontal e a y uma distância na posição vertical. A notação comumente utilizada para descrever um ponto é colocar ambas as coordenadas entre parênteses, separadas por vírgulas. Para evitar confusão e por ser mais próxima do que programaremos, usaremos a notação de números reais americana, com um “ponto” no lugar da vírgula. Assim, exemplos de coordenadas cartesianas seriam: (14.17, 50.23) ou (3, 4).

A figura abaixo, mostra o sistema cartesiano bidimensional, tal como vemos durante todo segundo grau. Ele é formado por dois eixos perpendiculares, definidos por duas retas marcadas numa unidade qualquer. O ponto (0,0), onde os dois eixos se cruzam em um ângulo de 90 graus, é chamado de origem. Quaisquer duas retas não colineares formam um plano (na verdade, basta uma reta e um ponto não colinear para definir um plano) e o plano formado pelo eixo cartesiano é o plano de desenho 2D.

Plano cartesiano 2D

Clipping de coordenadas

O sistema de coordenadas pode ser infinito, mas nossos monitores não são. Eles têm uma medida fixa, geralmente descrita em termos de pixels. Antes de iniciar o desenho, podemos dizer ao OpenGL como mapear os pares coordenados em unidades da tela, os pixels. Fazemos isso através da função void gluOrtho2D(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top). Essa função aceita quatro parâmetros, que definem a coordenada máxima e mínima que cada eixo ocupará na área de desenho.

A figura abaixo mostra alguns exemplos dessa função na prática:

Clipping

Também é possível fazer um eixo em que a menor coordenada esteja no topo e a maior na base, como é padrão em muitos aplicativos. Essa prática, entretanto, não é muito utilizada pela comunidade OpenGL.

A área onde o mapeamento é feito é chamada de clipping area, na tradução literal “área de recorte”. Isso porque mostramos ao OpenGL que parte do eixo cartesiano deve ser “recortada” para caber dentro da área de desenho.

Viewport: Definindo a área de desenho

Os jogos geralmente utilizam toda a área da tela para o desenho. Mas isso nem sempre é desejável para todos os tipos de aplicação. Usamos o comando void glViewport(GLint x, GLint y, GLsizei width, GLsizei height) para definir exatamente o local e a área onde queremos desenhar. Por estramos tratando aqui de coordenas da janela, dentro do monitor, todas as medidas são dadas em pixels.

Você também pode usar o Viewport para aumentar ou diminuir o tamanho da imagem.

Por padrão, o viewport do OpenGL ocupa toda a janela. Entretanto, é sempre recomendável executar o comando glViewport pois algumas implementações do OpenGL mais antigas simplesmente ignoram esse padrão e, sem o comando, não desenham nada.

Coordenadas cartesianas 3D

Não é muito difícil imaginar um eixo cartesiano com mais uma dimensão. Crie um eixo perpendicular tanto a y, quanto a x e chame-o de eixo z. Definimos os pontos a partir de 3 coordenadas e, voilá. Temos um novo eixo cartesiano, tridimensional.

Embora matematicamente perfeito, ao pensar no monitor alguns alarmes devem soar na sua cabeça. Afinal, nem todos tem um monitor 3D em casa, e seu preço inicial ainda é extremamente caro. Portanto, como podemos “espremer” três dimensões em apenas duas? Através de projeções, calculadas com base em trigonometria e matrizes. O OpenGL trabalha com duas formas diferentes de projeção.

Projeção ortográfica

O primeiro tipo de projeção é o mais utilizado em CADs, programas de arquitetura, e jogos isométricos. É chamada de projeção ortográfica, ou projeção paralela. Para criar essa projeção você desenha uma forma retangular. Tudo que está fora dessa forma, não é desenhado. Por isso volume definido por essa forma, é chamado volume de visualização (viewing volume). Todos os objetos parecem ter o mesmo tamanho, independente do quão próximos ou o quão afastados se encontrem. Você especifica a projeção ortográfica através da função void glOrtho(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far). O desenho abaixo, ajuda a entender cada um desses valores:

Projeção ortográfica

A funçao gluOrtho2D, vista no tópico anterior, simplesmente fornece os valores -1 e 1 para near e far.

Projeção em perspectiva

Ao falarmos de jogos 3D, a forma de projeção mais comum é a projeção em perspectiva. Essa projeção faz com que objetos mais distantes sejam desenhados em tamanho menor do que se estivessem próximos. Nessa projeção o viewing volume não é definido por um retângulo e sim por uma forma que lembra uma pirâmide que sofreu um corte paralelo a base, chamada de frustum.

A função que permite-nos definir o tamanho do frustum é a seguinte:

void glFrustum(GLdouble left, GLdouble right, GLdouble bottom, GLdouble top, GLdouble near, GLdouble far)

Abaixo, uma figura que nos ajuda a entender cada um desses parâmetros:

frustum

Uma das grandes dificuldades em usar essa função diretamente é saber o tamanho correto para os valores, de modo a formar uma imagem convincente. Para resolver esse problema, foi incluída na biblioteca de utilidades a função gluPerspective, que define o frustum baseada em outros parâmetros. A assinatura da função é a seguinte:

void gluPerspective( GLdouble fovy, GLdouble aspect, GLdouble zNear, GLdouble zFar )

Onde fovy é o ângulo de visão na direção y (valores convincentes para os humanos variam de 45 até 60 graus), aspect é a razão entre a largura e a altura, ou seja, x / y e near e far definem o quão longe ou próximo essa visão irá cobrir. Abaixo, uma figura descrevendo esses mesmos parâmetros:

frustum2

Combinando projeções

Tipicamente, num jogo 3D, combinamos dois tipos de projeções. Primeiro, desenhamos todo o cenário usando a projeção em perspectiva. Em seguida, utilizamos a projeção ortográfica 2D para desenhar o heads-up display, com as informações de vida, balas, pontuação, etc. Veja como exemplo a tela principal do Bola Gelada:

bolahud

A título de curiosidade, veja como foram definidas as funções no bola gelada:

  • Viewport: glViewport (0, 0, GAME_WINDOW.getWidth(), GAME_WINDOW.getHeight());
  • Perspectiva: gluPerspective(60.0f, GAME_WINDOW.getRatio(),1 ,15000);
  • HUD: gluOrtho2D(0, GAME_WINDOW.getWidth(), GAME_WINDOW.getHeight(), 0);

Usando os comandos

Todos os comandos vistos, exceto glViewport, precisam ser usados na matriz de projeção do OpenGl. Entraremos em mais detalhes sobre as matrizes nos próximos artigos, por hora, apenas decore a sintaxe. Abaixo, um exemplo com glOrtho2D, mas que vale também para glOrtho, glPerspective e glFrustum:

glMatrixMode(GL_PROJECTION);
   glLoadIdentity();  //Resetamos a projeção atual
   gluOrtho2D(0, GAME_WINDOW.getWidth(),
      GAME_WINDOW.getHeight(), 0);
glMatrixMode(GL_MODELVIEW);

Resumindo

  • Você viu como definir a clipping area, ou seja, o tamanho do eixo cartesiano na área de desenho, através da função gluOrtho2D;
  • Também aprendeu a como definir o tamanho da área de desenho através da função glViewport;
  • Viu como o OpenGL projeta coordenadas tridimensionais em bidimensionais;
  • Aprendeu a como definir o modo de projeção ortográfica usando a função glOrtho;
  • Entendeu que a projeção em perspectiva é mais adequada ao desenho 3D, e aprendeu a defini-la com a função glFrustum;
  • Viu que é possível combinar duas projeções, para desenhar o HUD de um jogo 3D.

Exercícios

  • Use a função glOrtho para criar um sistema de coordenadas proporcional a sua tela, como por exemplo de -40 até 40 na largura e de -30 até 30 na altura para uma janela em 800×600. Então, altere o seu cubo para ser desenhado nesse novo sistema. Note que o cubo parecerá melhor desenhado, agora que as coordenadas são proporcionais;
  • Agora use a função gluPerspective para desenhar o cubo em perspectiva (você terá que incluir o header “GL/GLU.h”). Você notará que o cubo parecerá ainda mais bem desenhado, já que o OpenGL desenhará a parte de trás ligeiramente menor que a parte da frente.

Importante: Por padrão, a câmera está localizada na origem e voltada para -z. Portanto, para você não ficar exatamente no centro do cubo ao aplicar esse comando, desloque-o usando o comando glTranslatef(x,y,z); antes de desenha-lo ou gira-lo, onde x, y e z são distâncias. Uma boa medida para os valores de x, y e z usando-se o glOrtho sugerido no primeiro exercício é (0,0, -10). Veremos detalhes sobre esse comando no próximo artigo.

  • Experimente o modo de perspectiva em outros exercícios, como o das pirâmides e o da mola.

Referências


Comentários (46)
  • Neto  - Duvida
    avatar

    tenho uma duvida. Com relação ao uso do OpenGL com a SDL. Todas as funções do open GL funcionam no SDL ? E vc tem alguma forma de resolver o problema de imput de teclados ineternacionais, porque algumas teclas retorna 0 como key e unicode;

  • Vinícius Godoy de Mendonça  - SDL
    avatar

    Sim, todas as funções do OpenGL funcionam na SDL.

    Na verdade, a SDL só monta a tela e abre a superfície OpenGL, a partir dali, você está usando OpenGL diretamente.

    O problema dos caracteres internacionais é que muitos são unicode. Nesse caso, você tem que trabalhar usando a função SDL_SetEnableUnicode(true);

    http://sdl.beuc.net/sdl.wiki/SDL_EnableUNICODE

  • Neto  - Mas...
    avatar

    Mesmo assim, mesmo ativando o SDL_EnableUNICODE e pegando as teclas com key.keysym.unicode ou seria key.unicode. ? Não lembro bem, a questão é que com as demais teclas funciona, exceto a do acento agudo (´) e a do til (~), pra furar esse buraco tive que fazer com scancode. Sabe me dizer o porque disso ?

  • Vinícius Godoy de Mendonça  - Unicode
    avatar

    Não sei o porque. :unsure:

    Nunca precisei fazer nada para valer usando SDL e Unicode.

    Se descobrir, por favor, compartilhe aqui com a gente.

  • Neto  - re: Unicode
    avatar
    Vinícius Godoy de Mendonça Escreveu:
    Não sei o porque. :unsure:

    Nunca precisei fazer nada para valer usando SDL e Unicode.

    Se descobrir, por favor, compartilhe aqui com a gente.

    q pena.... pelo jeito não sou só eu que tenho esse problema. Afinal de contas como a SDL obtem os caracters internacionais ? E porque ele retorna um Uint16 ? Pelo que me consta existem caracteres que superam e muito esse tipo de dados.

  • Bruno Crivelari Sanches
    avatar

    Essa eu (acho que) sei! :woohoo:

    Existem varios formatos Unicode, o da SDL pelo jeito é o UTF-16, são 65536 caracteres e acho que já li em algum lugar que da conta do recado sim.

    Além deste tem o UTF32 e o que acho mais pratico UTF-8.

    Se não me engano a API do windows é UTF-16, dai a escolha da SDL e acredito que no Windows eles peguem isso diretamente da API dele.

  • Neto  - HUm....
    avatar

    A tah, agora saquei. Mas só não entendo o pq fica dandos esses erros se o UNICODE era justamente para teclados internacionais. Acabei de fazer um exemplo aki e até a tecla "P" retorna 0 com UNICODE. Algum de vcs poderia fazer testes para comprovar minhas duvidas, porque pode ocorrer de ser meu SDL com defeito ou mau uso de código. t++

  • Bruno Crivelari Sanches
    avatar

    Fiz um teste aqui e parece funcionar. Posta o código num daqueles notepad onlines para a gente ver.

    T+

  • Neto  - re:
    avatar

    O BCS respondeu, o lance que só sai unicode do acento agudo depois que aperta outra tecla. Vlw as respostas pessoal.

  • Vinícius Godoy de Mendonça
    avatar

    Mesmo o padrão unicode estendido tem apenas 16 bytes por "default". O que acontece é que tem um valor no primeiro byte que daí indicará que seguem mais dois bytes após aquele.

    Ou seja, pelo unicode completo, fica virtualmente impossível saber o número de caracteres de um texto só olhando o número de bytes dele.

    Mas não sei se a SDL trabalhar com esse padrão, creio que não.

  • Anônimo  - re:
    avatar
    Vinícius Godoy de Mendonça Escreveu:
    Mesmo o padrão unicode estendido tem apenas 16 bytes por "default". O que acontece é que tem um valor no primeiro byte que daí indicará que seguem mais dois bytes após aquele.

    Ou seja, pelo unicode completo, fica virtualmente impossível saber o número de caracteres de um texto só olhando o número de bytes dele.

    Mas não sei se a SDL trabalhar com esse padrão, creio que não.

    Obrigado por mais esse esclarecimento. Sendo assim, já que todas as minhas perguntas foram respondidas, então reservo-me o direito de dar um fim nessa discurção. T++ galera vlw .

  • Jose Carlos Pinna
    avatar

    Muito bom! Não vejo a hora de entrar textura, tenho algumas duvidas.
    Tenho um bmp rico em detalhes com muita gradiente 1024/768 na allegro vai bem mais quando passo para opengl eu tenho que mexer no tamanho dela para que a opengl aceite e depois o filtro faz os ajustes mais percebo que acaba perdendo qualidade em alguns pontos sou muito iniciante no opengl mais espero que quando entrar em textura eu entenda o que esta acontecendo.

  • Vinícius Godoy de Mendonça  - Texturas
    avatar

    Bem. As texturas no OpenGL tem que ter largura e altura que sejam potências de 2. Placas mais novas renderizam outros tamanhos, mas com perda de qualidade ou performance.

    Tente alterar sua textura para um tamanho como 512x512, e veja se a performance melhora. Outra coisa, é possível também configurar os filtros de textura.

    Alguns filtros tem melhor qualidade que outros, e é aí que entram aquele configurações que os jogos dão de "bilinear", "trilinear", "anisotrópico", etc... veremos mais sobre essas configurações no artigo sobre texturas.

  • Pinna
    avatar

    Eu ja tentei usando exemplos prontos só trocando pelo meu bmp alterando o tamanho mais quando comparo com o original tem perda de qualidade mais com certeza é falta de conhecimento meu vou estudar esses filtros .
    Valeu!!

  • Anônimo
    avatar

    Vinícius desculpe se estou sendo inconveniente mais quando estou pesquisado na net sempre vejo comentários bons seus e por isso acho que você é a pessoa mais indicada para me ajudar.
    Às vezes estou estudando c++ opengl, como agora mais ai eu dou uma fuçada nessas engines profissionais e ate essas gratuitas e fico em duvida devo estudar as engines, devo estudar Java quero me dedicar em uma coisa só para aprender bem quero me tornar um bom programador e quem sabe um dia trabalhar na área; por favor, qual a sua opinião.

  • Vinícius Godoy de Mendonça
    avatar

    Primeiro de tudo, você já tem alguma curso de graduação? Se não tiver, comece por aí, preferencialmente, com algum curso de ciência ou engenharia da computação.

    É importante aprender a programar bem. E isso inclui:
    a) Entender os conceitos básicos: saber bem OO, saber bem estruturas de dados, saber bem matemática (se você for pegar CG ou física). Enfim, entender os conceitos;
    b) Ter boas noções sobre boas práticas de programação: Refatoração, desenvolvimento orientado a testes, ler livros como "Effective C++" ou "Effective Java", conhecer bem as APIs que você está usando;
    c) Ter boas noções sobre processos de desenvolvimento;

    Note que nada disso envolve uma linguagem específica, ou uma engine. Linguagem e engine são ferramentas.

    Se você quer entrar na indústria de jogos, especificamente, pode ser uma boa idéia fazer em seguida uma pós-graduação na área. Assim você conhece bem os campos que a área de jogos contempla (CG, IA, Matemática e Física, Redes, Etc).

    Quanto à linguagem, se você tem pretensões de entrar de cabeça na indústria, procure olhar com mais carinho para o C++. É a linguagem mais usada na indústria de jogos.

    Engines são interessantes para um desenvolvimento mais agradável e mais rápido, mas mesmo elas exigem que você tenha um certo conhecimento do básico, antes de começar. Por isso, mesmo se usa-las, será bom conhecer como a placa de vídeo funciona, ou os conceitos do OpenGL e do DirectX de iluminação, texturas, shaders, etc.

  • Anônimo
    avatar

    Muito obrigado pela sua opinião mais infelizmente faculdade não da para min eu achava que seria possível estudar com livros e net.

  • Vinícius Godoy de Mendonça
    avatar

    Ué, por que você não pode fazer faculdade?

    Bom, comece então pelo roadmap C++ que tem aqui mesmo no site.

  • Anônimo
    avatar

    Muito obrigado gostei do que vc falou. (Linguagem e engine são ferramentas.)

  • Anônimo
    avatar

    eu quero sabe o que e coordenadas cartezianas :?:

  • thalles  - bom
    avatar

    :) texto muito bom explica bem!!!mas eu sou ruim nessa matéria!!!kkkk

  • Vinícius Godoy de Mendonça
    avatar

    Valeu Thalles.

    Realmente, é muito difícil aprender qualquer matéria mais matemática sem um bocado de estudo. Mas espero que conhecendo os resultados interessantes do que se possa fazer, você se sinta mais motivado. ;)

  • Anônimo  - re:
    avatar

    tudo bem? queria sabe se posso usar esse trabalho como um trabalho revisado de sistemas de coordenadas e projeções?? trabalho de topografia!

    Abraço!!

  • Vinícius Godoy de Mendonça
    avatar

    Não entendi nada. Você quer usar esse texto como se fosse seu trabalho?

  • victor bruno  - funcoes do segundo grau
    avatar

    Dada uma funçao do segundo grau, fazer o grafico. Como posso fazer programa?

  • Vinícius Godoy
    avatar

    Faça um for para os valores de x. E para cada valor, calcule a função e plote o ponto calculado em y.

  • Victor Bruno  - Funcao 2 grau opengl
    avatar

    No caso so mais uma duvida. Vou receber como entrada a funcao
    ax²+b+c. Como posso chegar nos valores que terei para o x?

  • ViniGodoy
    avatar

    O usuário terá que informar os valores de a, b e c. Sem informá-los, seria impossível traçar qualquer desenho.

    Aí, basta realizar os cálculos variando em x com um for e calculando y.

    Por exemplo, digamos que o usuário informe 1 para a, 5 para b e 15 para c. Você faz um for de x =-100 até 100. E então calcula:
    Para x = -100 ==> 1*(-100)²+5*100+15=10.000+500+15 = 10.515. Logo, o primeiro ponto é (-100, 10.5015).

    Cada passo do for, você obterá mais um valor de x e y.

    Vai fazendo isso para todos os x, e você terá ao final sua função desenhada.

  • Victor Bruno  - grafico opengl
    avatar

    Desde já agradeço muito a atenção.
    estou tentando fazer dessa forma:
    float a,b,c,x,y;
    a=1;
    b=5;
    c=15;
    for(x=-100; x

  • Anônimo
    avatar

    Se quiser postar código, use o codepad: http://codepad.org/

  • Xico  - Muito bom!
    avatar

    Cara, muito bom mesmo a explicação toda que você deu sobre essas funções de coordenadas! Não achava nenhum lugar que explicasse para que realmente ela servia! Valeu e espero que continue com esse trabalho!

  • Xico  - Usar o glFustum
    avatar

    Será que dá pra me ajudar na glFrustum? Já coloquei tudo quanto é valor nele, mas aparentemente ele não altera nada na figura...

    Código:

    #include
    #include
    #include
    #include
    using namespace std;
    int anguloX=0;
    int anguloY=0;
    int anguloZ=0;

    void Inicializa (void)
    {
    glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
    glMatrixMode(GL_PROJECTION); // Especifica sistema de coordenadas de projeção
    glLoadIdentity(); // Inicializa sistema de coordenadas de projeção
    glFrustum(-1,-1,1,1, -5,3);
    }

    void Desenha(void)
    {
    glMatrixMode(GL_MODELVIEW); //Alterações são aplicadas aos objetos da cena
    glLoadIdentity(); //Reseta a matriz

    glClear(GL_COLOR_BUFFER_BIT);
    glRotatef(anguloY, 0, 1, 0);
    glRotatef(anguloX, 1, 0, 0);
    glRotatef(anguloZ, 0, 0, 1);

    glBegin(GL_TRIANGLES);
    glColor4f(0.0f, 1.0f, 0.0f, 1.0f);
    glVertex3f(0.5, 0, 0.5);
    glVertex3f(0.5, 0.5, 0);
    glVertex3f(0, 0, 0);
    glColor4f(0.0f, 0.0f, 1.0f, 1.0f);
    glVertex3f(0, 0, 0);
    glVertex3f(0.5, 0, 0.5);
    glVertex3f(0.5, 0, 0);
    glColor4f(0.5f, 0.5f, 0.5f, 1.0f);
    glVertex3f(0.5, 0, 0);
    glVertex3f(0.5, 0.5, 0);
    glVertex3f(0.5, 0, 0.5);
    glColor4f(1.0f, 0.0f, 0.0f, 1.0f);
    glVertex3f(0, 0, 0);
    glVertex3f(0.5, 0.5, 0);
    glVertex3f(0.5, 0, 0);
    glEnd();

    glMatrixMode(GL_PROJECTION); // Especifica sistema de coordenadas de projeção
    glLoadIdentity(); // Inicializa sistema de coordenadas de projeção
    glFrustum(-1,-1,1,1, -1,3);
    glutSwapBuffers();
    }

    void Teclado(unsigned char key, int x, int y)
    {
    if (key == 'x')
    anguloX += 10;
    if (key == 'y')
    anguloY += 10;
    if (key == 'z')
    anguloZ += 10;
    Desenha();
    }

    int main(void)
    {
    glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB); //Dois buffers, sistema RGB
    glutInitWindowSize(800, 600); // Tamanho da janela
    glutInitWindowPosition(0, 0); // Posição inicial da janela
    glutCreateWindow("Cubo";); // Nome da janela
    Inicializa();
    glutDisplayFunc(Desenha);
    glutKeyboardFunc(Teclado);
    glutMainLoop();
    }

    PS: Desculpe a desorganização. Criei só pra tentar resolver isso... Ah, e não estou usando SDL, só o OpenGL puro.

  • ViniGodoy
    avatar

    Por favor, poste código em algum serviço como o pastebin.

    Outra coisa, não existe "opengl puro". No lugar da SDL você está usando a glut.

    Quanto ao glFrustum. Ele é extremamente difícil de usar, você teria que apelar para um bocado de geometria. No lugar, prefira usar o gluPerspective, que permite que você passe só a distância near e far, e o ângulo de abertura vertical da câmera.

  • Xico
    avatar

    Rapaz, eu já tinha tentado usar o gluPerspective, mas não tava aparecendo nada (só o preto). Deduzi que era porque tinah passado os valores incorretos pra ele (a figura não estava no campo de visão). Mas agora fui mexer e deu a mesma coisa do glFrustum: eu só vejo um triangulo vermelho, como se tivesse vendo a figura a partir do eixo Z. Até que eu acharia normal, mas o problema é que altero os valores, mas nada muda... Só fica nesse triângulo!!!
    Será que você sabe me dizer se tem algo errado na forma que estou tentando usar?
    PS: pra usar o glPerspective usei o mesmo código anterior. Apenas troquei a glFrustum pela glPerspective e os argumentos da função, claro. Usei vários valores, de tudo 0 até tudo 1000, mas só vejo a mesma coisa...

  • Vinícius Godoy de Mendonça
    avatar

    Se você vai usar o gluPerspective, tem que também configurar a câmera com o comando gluLookAt.

    Agora, vai ser hora de começar a prestar atenção na escala do seu modelo, e tentar começar a pensar na cena em 3D. Em que local está o observador, para onde ele olha, a que distância ele está do objeto sendo observado, etc.

  • Xico
    avatar

    Consegui,! Acho que era o gluKooAt mesmo... e eu também não tava entendo bem a visão da coisa! Valeu aê pela ajuda!

  • Anônimo
    avatar

    Versão do nehe: http://nehe.gamedev.net/article/replacement_for_gluperspective/21002/< /p>

  • Xico  - re:
    avatar
    Xico Escreveu:
    Consegui,! Acho que era o gluKooAt mesmo... e eu também não tava entendo bem a visão da coisa! Valeu aê pela ajuda!

    Consegui! Acho que era o gluLooAt mesmo... e eu também não tava entendendo bem a visão da coisa! Valeu aê pela ajuda!

  • fredy  - escala de [0,1m...10m]
    avatar

    como eu seto o meu sistema de coordenadas para trabalhar num intervalo de escala de 0,1m a 10m?

  • Anônimo
    avatar

    Esse tipo de conceito não existe em opengl ou qualquer api gráfica. Cabe ao desenvolvedor definir o que os números significam.

    Logo, glPoint3f(1, 1, 1) pode significar 1m, 1km, 1cm, 1mm, etc. Depende da sua aplicação.

  • fredy
    avatar

    obrigado companheiro...

  • robson eduardo  - pequena correção
    avatar

    Você diz no tópico "Coordenadas Cartesianas 2D" que quaisquer duas retas não colineares definem um plano, mas isso só é válido para retas concorrentes ou paralelas, não para quaisquer retas. você não consegue um plano que contenha as retas r e s abaixo por exemplo, por serem reversas.

    rx=ry=rz=t

    sx=1-t
    sy=t
    sz=t

    Obrigado pelo artigo. Me foi extremamente útil. Extremamente mesmo!

  • Vinigodoy
    avatar

    Essas retas são em 3d. O artigo se referia a 2d.

Escrever um comentário
Your Contact Details:
Gravatar enabled
Comentário:
[b] [i] [u] [url] [quote] [code] [img]   
:angry::0:confused::cheer:B):evil::silly::dry::lol::kiss::D:pinch::(:shock:
:X:side::):P:unsure::woohoo::huh::whistle:;):S:!::?::idea::arrow:
Security
Por favor coloque o código anti-spam que você lê na imagem.
LAST_UPDATED2  

Busca

Linguagens

Twitter