[Opengl] Movimentos de objectos

[alves077]

Boa tarde,

Sendo iniciante a opengl, criei dois objectos em 3D, que estão em determinada posição inicial, queria que eles estivessem constantemente a navegar pela janela, entre os limites, mas nao sei muito bem como fazer, pensei tendo eu os segundos do sistema ir alterando a translação segundo os mesmos segundos. Mas acho que não vou conseguir o pretendido. Fazem ideia como posso fazer?

Um excerto dos objectos criados,neste caso com base em vários quadrados, e outro com vários triângulos

glViewport(0,0,wScreen,hScreen);
glMatrixMode(GL_PROJECTION);
gluPerspective(45.0f,wScreen/hScreen,0.1f,100.0f);


glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
glTranslatef(1.5f, 0.0f, -7.0f);
glScalef(0.5,0.5,0.5);

glBegin(GL_QUADS);
  glColor3f(0.0f, 1.0f, 0.0f);	
  glVertex3f( 1.0f, 1.0f, -1.0f);
  glVertex3f(-1.0f, 1.0f, -1.0f);
  glVertex3f(-1.0f, 1.0f,  1.0f);
  glVertex3f( 1.0f, 1.0f,  1.0f);

  // Lado do fundo (y = -1.0f)
  glColor3f(1.0f, 0.5f, 0.0f);	
  glVertex3f( 1.0f, -1.0f,  1.0f);
  glVertex3f(-1.0f, -1.0f,  1.0f);
  glVertex3f(-1.0f, -1.0f, -1.0f);
  glVertex3f( 1.0f, -1.0f, -1.0f);

  // Lado da Frente  (z = 1.0f)
  glColor3f(1.0f, 0.0f, 0.0f);
  glVertex3f( 1.0f,  1.0f, 1.0f);
  glVertex3f(-1.0f,  1.0f, 1.0f);
  glVertex3f(-1.0f, -1.0f, 1.0f);
  glVertex3f( 1.0f, -1.0f, 1.0f);

  // Lado de traz (z = -1.0f)
  glColor3f(1.0f, 1.0f, 0.0f);	
  glVertex3f( 1.0f, -1.0f, -1.0f);
  glVertex3f(-1.0f, -1.0f, -1.0f);
  glVertex3f(-1.0f,  1.0f, -1.0f);
  glVertex3f( 1.0f,  1.0f, -1.0f);

  // Lado esquerdo (x = -1.0f)
  glColor3f(0.0f, 0.0f, 1.0f);  
  glVertex3f(-1.0f,  1.0f,  1.0f);
  glVertex3f(-1.0f,  1.0f, -1.0f);
  glVertex3f(-1.0f, -1.0f, -1.0f);
  glVertex3f(-1.0f, -1.0f,  1.0f);

  // Lado direito (x = 1.0f)
  glColor3f(1.0f, 0.0f, 1.0f);  
  glVertex3f(1.0f,  1.0f, -1.0f);
  glVertex3f(1.0f,  1.0f,  1.0f);
  glVertex3f(1.0f, -1.0f,  1.0f);
  glVertex3f(1.0f, -1.0f, -1.0f);
glEnd();

glLoadIdentity();
glTranslatef(-1.5f, 0.0f, -6.0f);
glScalef(0.5,0.5,0.5);

glBegin(GL_TRIANGLES);	
  //Lado frente
  glColor3f(1.0f, 0.0f, 0.0f);	
  glVertex3f( 0.0f, 1.0f, 0.0f);
  glColor3f(0.0f, 1.0f, 0.0f);  
  glVertex3f(-1.0f, -1.0f, 1.0f);
  glColor3f(0.0f, 0.0f, 1.0f);	
  glVertex3f(1.0f, -1.0f, 1.0f);

  // Lado direito
  glColor3f(1.0f, 0.0f, 0.0f);	
  glVertex3f(0.0f, 1.0f, 0.0f);
  glColor3f(0.0f, 0.0f, 1.0f);	
  glVertex3f(1.0f, -1.0f, 1.0f);
  glColor3f(0.0f, 1.0f, 0.0f);	
  glVertex3f(1.0f, -1.0f, -1.0f);

  // Lado tras
  glColor3f(1.0f, 0.0f, 0.0f);  
  glVertex3f(0.0f, 1.0f, 0.0f);
  glColor3f(0.0f, 1.0f, 0.0f);	
  glVertex3f(1.0f, -1.0f, -1.0f);
  glColor3f(0.0f, 0.0f, 1.0f);	
  glVertex3f(-1.0f, -1.0f, -1.0f);

  // Lado esquerdo
  glColor3f(1.0f,0.0f,0.0f);	
  glVertex3f( 0.0f, 1.0f, 0.0f);
  glColor3f(0.0f,0.0f,1.0f);	  
  glVertex3f(-1.0f,-1.0f,-1.0f);
  glColor3f(0.0f,1.0f,0.0f);	  
  glVertex3f(-1.0f,-1.0f, 1.0f);
glEnd();

Obrigado pela atenção,

alves077

Edited April 10, 2013 at 07:04 PM by alves077

[HappyHippyHippo]

não vais conseguir fazer por várias razões :

- estás a desenhar os triângulos com valores estáticos ... é impossivel actualizar/alterar isso

- segundos é uma unidade de tempo demasiado grande para o que pretendes

- para um movimento existem duas/três componentes que não definiste : direcção/sentido (pode ser feito num só passo com um vector) e velocidade

- necessitas de saber os limites do cone de visualização para que os objectos não saiam da janela.

existem soluções simples e complexas, mas vamos somente ver as simples:

- usa estruturas ou arrays (qualquer coisa) para guardar as posições dos vertices dos objectos a serem desenhados

- no que toca ao tempo, podes usar a função clock, e com ela saber a resolução do frame a ser apresentado

- como disse acima, podes usar um vector para codificar tudo : direcção/sentido e com o seu tamanho, podes guardar a velocidade

- para não teres de trabalhar (já) em 3D no que toca ao plano de movimento, podes calcular os limites de visualização a um plano paralelo ao plano de projecção (talvez o z=0 para simplificar)

de resto, é fazer a actualização dos vertices dos objectos dependendo da velocidade/sentido e o tempo decorrido (clock) antes de cada frame

[alves077]

hm ok..

Mas sinceramente ainda não percebi bem, como simplesmente faço mexer, como altero a sua posição, a ideia de ter um array ja tinha ouvido falar, em vez de definir ocm glBegin os pontos glEnd, com

GLfloat tam=1;

static GLfloat vertices[]={
       -tam,  -tam,  tam, 
       -tam,   tam,  tam, 
       -tam,   tam, -tam,
       -tam,  -tam, -tam, 
        tam,  -tam,  tam,
        tam,   tam,  tam, 
        tam,   tam, -tam,
        tam,  -tam, -tam, 
       -tam,  tam,  tam, 
       -tam,  tam, -tam,
        tam,  tam, -tam, 
        tam,  tam,  tam, 
};

e com as função glEnableClientState(), glVertexPointer(), glNormalPointer(), consigo criar o objecto em determinada posição, mas como disse, não percebo como posso mover ao longo do tempo. A questão do tempo com ajuda da função glutTimerFunc(), fazia glutPostRedisplay() e ele actualiza a cada x tempo. Não percebo a ideia de guardar o sentido e a direcção, e mexer com eles...

Obrigado pela atenção,

alves077

Edited April 10, 2013 at 09:01 PM by alves077

[HappyHippyHippo]

tenho que pedir desculpa por uma razão :

estava a pensar num projecto que estava a realizar e não dei o concelho correcto

- estás a desenhar os triângulos com valores estáticos ... é impossivel actualizar/alterar isso

é verdade que o código fica restringido pelos valores estáticos, mas para o teu problema não é problema nenhum. basta aplicar as transformações correctas.

agora, no que toca às tuas dúvidas ... só mesmo seguindo um tutorial, porque estar a explicar tudo é impossível.

segue estes tutoriais que é bom para quem está a começar.

é certo que não usa o glut, e o código apresentado usa o WinAPI, mas isso é facilmente alterado para um programador com um pouco de atenção ao que está a ler.

[alves077]

Vou tentar guiar pelos tutoriais, a ideias que ainda não são claras, vou me documentar. Obrigado pelos conselhos.

[shumy]

Transladar, rodar, é feito com matrizes.

Os NeHe são bons tutoriais, mas já são bem antigos.

A não ser que seja para um projecto escolar, eu recomendaria que aprendesses a API mais moderna do opengl, visto que o "immediate mode" já está "deprecated" (não é utilizado), e nem sequer está disponível no opengl ES 2.

O problema... tens de aprender alguma coisa de shaders e GLSL, o que é mais complicado iniciar.

No entanto depois de aprender, faz mais sentido, é mais uniforme e programável, com imensas aplicações.

http://www.lighthouse3d.com/tutorials/glsl-core-tutorial/

Quando começares a perceber melhor de GLSL, podes brincar online http://glsl.heroku.com/ embora só esteja disponivel a parte do "fragment shader".

Ir por este caminho, vais ter de ser praticamente obrigado a aprender melhor como o pipeline opegl funciona, matrizes e shaders.