OpenGL com Java

Você pode ganhar um iPad 2 na promoção do Javafree

O Portal javafree.org inicia mais uma promoção para os usuários do fórum. Quem publicar mais posts válidos (perguntas ou respostas) entre 16/4 a 13/7 levará para casa um iPad 2 de 16GB!

Clique aqui e saiba mais.

Home > Artigos > Java em Geral >

Publicado por Edinei Manica em 16/08/2009 - 36.453 visualizações

comentários: 1

Trabalhando com o Open GL com Java
Por: Edinei Manica
e-mail: edineimanica@javafree.com.br

Introdução

O OpenGl é uma biblioteca de rotinas gráficas para modelagem em 2 ou em 3D. O OpemGl permite o uso de iluminação, mapeamento de textura,transparência, sombreamento, animações, mas como esse tutorial é básico do OpenGl não chegaremos a utilizar todos estes recursos.
O OpenGl possui cerca de 150 comandos. As especificações do OpenGL não descrevem as interações entre OpenGL e o sistema de janelas utilizado. Assim, tarefas como criar janelas gráficas, gerenciar eventos ficam a cargo de bibliotecas próprias de cada sistema operacional.
Os principais fabricantes de Pcs adotaram como estratégia de padrão aberto para Hardware gráfico o OpenGl dentre elas a Compaq, a Sony, a Sun Mycrosystems, a Samsung dentre outras.
Hoje em dia nos temos vários jogos e CAD que utilizam o OpeGl, como por exemplo o famoso jogo quake e o famoso programa para modelagem Maya.
Neste tutorial veremos as transformações de translação, rotação e mudança de escala isso de forma bem fácil, sem precisar realizar cálculos com matrizes de transformações, isso por que a biblioteca para Java já implemento métodos para facilitar estas transformações.
Site oficial: htttp://www.opengl.org.

Instalando o OpenGl

Para realizar a instalação do OpenGl entre na página http://www.gopengl.org/tutoriels/configurerjava.php , e baixe as dlls que você deve adicionar em seu sistema.
- libGL4Java2.8.2.0-Win32-x86.zip

E as librarys necessárias, e adicione as em seu projeto.
- gl4java2.8.2.0-jar.zip,
- gl4java2.8.2.0-glffonts-jar.zip,
- gl4java2.8.2.0-glutfonts-jar.zip
- png-1.0a-jar.zip.

Trabalhando com o OpenGl

Primeiramente foi criada uma classe que contém todas as propriedades de cada objeto, como cor, quem é filho dele, etc. E permitindo que se altere estas propriedades.

import javax.swing.*;

public class CriaObjeto extends Object
{
  public static int indiceNodo = 0;
  
  public  String nome = "";
  public  double corRed = 0;
  public  double corGreen = 0;
  public  double corBlue = 0;   
  public  double vertices[][] = null;
  public  double translateX = 0;
  public  double translateY= 0;
  public  double scalaX = 1;
  public  double scalaY = 1;
  public  double rotateX = 0;
  public  double rotateY = 0;
  public  double rotateZ = 0;
  public  double angulo = 0;
  public  int[] filhos = new int[]{};
   
  public String getNome()
  {
     return nome;  
  }
  
  public void setNome(String nm)
  {
    nome = nm;
  }
  
  
  public double getCorRed()
  {
      return corRed;
  }
  
  public void setCorRed(double corR)
  {
     this.corRed = corR;
  }
  
  public double getCorGreen()
  {
     return corGreen;
  }
  
  public void setCorGreen(double corG)
  { 
     this.corGreen = corG; 
  }
  
  public double getCorBlue()
  {
    return corBlue;
  }
  
  public void setCorBlue(double corB)
  {
     this.corBlue = corB;
  }

public double getTranslateX()
  {
    return translateX;
  }
  
  public void setTranslateX(double pX)
  {
     this.translateX = translateX + pX;
  }
  
  public double getTranslateY()
  {
    return translateY;
  }

public void setTranslateY(double pY)
  {
     this.translateY = translateY + pY ;
  }
   
  public double getScalaX()
  {
     return scalaX;
  }
  
  public void setScalaX(double sX)
  {
      this.scalaX = scalaX +  sX;
  }
  
  
  public double getScalaY()
  {
    return scalaY;
  }

public void setScalaY(double sY)
  {
      this.scalaY = scalaY + sY;
  }
  
  public double getRotateX()
  {
     return rotateX;
  }
  
  public void setRotateX(double dx)
  {
     this.rotateX = dx;
  }
  
  public double getRotateY()
  {
    return rotateY;
  }
  
  public void setRotateY(double dy)
  {
     this.rotateY = dy;
  }
  public double getRotateZ()
  {
    return rotateZ;
  }
  
  public void setRotateZ(double dZ)
  {
     this.rotateZ = dZ;
  }
 
  public double getAngulo()
  {
    return angulo;
  }
  
  public void setAngulo(double rangulo)
  {
     this.angulo =angulo + rangulo  ;
  }
  
  public int[] getfilhos()
  {
     return filhos ;
  }   
  
  public void setFilhos(int[] filhos)
  {
     this.filhos = filhos;
  }

public double[][] getVertice()
  {
    return vertices;
  }

public void setVertice(double [][] vertice)
  {
    this.vertices  = vertice;
  }

public void reset()
  {
    translateX = 0;
    translateY= 0;
    scalaX = 1;
    scalaY = 1;
    rotateX = 0;
    rotateY = 0;
    rotateZ = 0;
    angulo = 0;
  }
  
}

A segunda classe é onde são criados os objetos, e os eventos para a realização de uma determinada transformação.

import gl4java.swing.*;
import java.awt.event.*;
import java.awt.*;
import javax.swing.*;

public class OpenGLTesteManica extends GLAnimJPanel implements ActionListener
{
  private CriaObjeto[] objetos = null;
  private JPanel pnlSul = new JPanel();

private JButton btnResetar = new JButton("Resetar");

private JLabel lblListObjeto = new JLabel("Objeto:");
  private JComboBox cbxListObjetos = new JComboBox();

//Componentes para a rotação
  private JLabel lblRotateAngulo = new JLabel("Angulo:");
  private JTextField txfRotateAngulo = new JTextField(4);
  private JLabel lblRotateX = new JLabel("X:");
  private JTextField txfRotateX = new JTextField(4);
  private JLabel lblRotateY = new JLabel("Y:");
  private JTextField txfRotateY = new JTextField(4);
  private JLabel lblRotateZ = new JLabel("Z:");
  private JTextField txfRotateZ = new JTextField(4);
  private JButton btnRotate = new JButton("Rotação");

//Componentes para a translação
  private JLabel lblTranslateX = new JLabel("X:");
  private JTextField txfTranslateX = new JTextField(4);
  private JLabel lblTranslateY = new JLabel("Y:");
  private JTextField txfTranslateY = new JTextField(4);  
  private JButton btnTranslacao = new JButton("Translação");

//Componentes para a mudança de scala
  private JLabel lblScaledX = new JLabel("X:");
  private JTextField txfScaledX = new JTextField(4);
  private JLabel lblScaledY = new JLabel("Y:");
  private JTextField txfScaledY = new JTextField(4);  
  private JButton btnScaled = new JButton("Escala");

private int nrObjetos = 0;
  private int indiceObjetos = 0;
  
  public OpenGLTesteManica()
  {
     nrObjetos = 7;
     iniciaObjetos();
     populaCombo();
     Inicializa();
  }

public void Inicializa()
  {
     
     int[][] idisn ={{1,12},{13,14},{15,16}}; 
     
     super.setBackground(Color.black);
     super.setLayout(new BorderLayout());
     pnlSul.setLayout(new GridBagLayout());

pnlSul.add(lblListObjeto, new GridBagConstraints(0,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(cbxListObjetos, new GridBagConstraints(1,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(btnResetar,  new GridBagConstraints(0,3,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     // Adicionando componentes para rotação
     pnlSul.add(lblRotateAngulo,new GridBagConstraints(2,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfRotateAngulo,new GridBagConstraints(3,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(lblRotateX,     new GridBagConstraints(2,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfRotateX,     new GridBagConstraints(3,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(lblRotateY,     new GridBagConstraints(2,2,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfRotateY,     new GridBagConstraints(3,2,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(lblRotateZ,     new GridBagConstraints(2,3,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfRotateZ,     new GridBagConstraints(3,3,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(btnRotate,      new GridBagConstraints(4,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     //Adicionando componentes para a translacao
     pnlSul.add(lblTranslateX,  new GridBagConstraints(5,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfTranslateX,  new GridBagConstraints(6,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(lblTranslateY,  new GridBagConstraints(5,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfTranslateY,  new GridBagConstraints(6,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(btnTranslacao,  new GridBagConstraints(7,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     //Adicionando componenes para a mudança de escala
     pnlSul.add(lblScaledX,     new GridBagConstraints(8,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfScaledX,     new GridBagConstraints(9,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(lblScaledY,     new GridBagConstraints(8,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(txfScaledY,     new GridBagConstraints(9,1,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));
     pnlSul.add(btnScaled,      new GridBagConstraints(10,0,1,1,0.0,0.0,GridBagConstraints.CENTER,GridBagConstraints.NONE,new Insets(0,0,0,5),0,0));

btnResetar.setMargin(new Insets(0,0,0,0));

add(pnlSul, BorderLayout.SOUTH);
     btnRotate.addActionListener(this);
     btnScaled.addActionListener(this);
     btnTranslacao.addActionListener(this);
     btnResetar.addActionListener(this);
  }

public void actionPerformed(ActionEvent evt)
  {
    int indice = cbxListObjetos.getSelectedIndex();
    if(evt.getSource() == btnRotate)
    {
      try{
        if(txfRotateAngulo.getText().equals(""))
           txfRotateAngulo.setText("0");
        if(txfRotateX.getText().equals(""))
           txfRotateX.setText("0");
        if(txfRotateY.getText().equals(""))
           txfRotateY.setText("0");
        if(txfRotateZ.getText().equals(""))
           txfRotateZ.setText("0");
           
        objetos[indice].setAngulo(Double.parseDouble(txfRotateAngulo.getText()));
        objetos[indice].setRotateX(Double.parseDouble(txfRotateX.getText()));
        objetos[indice].setRotateY(Double.parseDouble(txfRotateY.getText()));
        objetos[indice].setRotateZ(Double.parseDouble(txfRotateZ.getText()));
      }catch(Exception ex)
      {
         System.out.println(ex);
      }
    }
    else if(evt.getSource() == btnScaled)
    {
      try{
        if(txfScaledX.getText().equals(""))
          txfScaledX.setText("0");
        if(txfScaledY.getText().equals(""))
          txfScaledY.setText("0");
        
        objetos[indice].setScalaX(Double.parseDouble(txfScaledX.getText())/10);
        objetos[indice].setScalaY(Double.parseDouble(txfScaledY.getText())/10);
      }catch(Exception ex)
      {
         System.out.println(ex);
      }
    }
    else if(evt.getSource() == btnTranslacao)
    {
      try{
        if(txfTranslateX.getText().equals(""))
          txfTranslateX.setText("0");
        if(txfTranslateY.getText().equals(""))
          txfTranslateY.setText("0");
         
        objetos[indice].setTranslateX(Double.parseDouble(txfTranslateX.getText()));
        objetos[indice].setTranslateY(Double.parseDouble(txfTranslateY.getText()));
      }catch(Exception ex)
      {
         System.out.println(ex);
      }
    }
    else if(evt.getSource() == btnResetar)
    {
      for(int i = 0 ; i < nrObjetos; i++)
      {
        objetos[i].reset();
      }
    }
  }

public void iniciaObjetos()
  {
    objetos = new CriaObjeto[nrObjetos];
    for(int i = 0; i < nrObjetos ; i++)
    {
      objetos[i] = new CriaObjeto();
    }
      
    objetos[0].setNome("Cena");
    objetos[0].setFilhos(new int[]{1,6});

objetos[1].setNome("Objeto1.1");
    objetos[1].setVertice(new double[][]{{-50,-40},{-50,-30},{-1,-30},{-1,-40}});
    objetos[1].setCorRed(1);
    objetos[1].setFilhos(new int[]{2,3});

objetos[2].setNome("Objeto1.2")   ;
    objetos[2].setVertice(new double[][]{{-50,-5},{-55,-5},{-55,0},{-50,0}});
    objetos[2].setCorGreen(1);

objetos[3].setNome("Objeto1.3");
    objetos[3].setVertice(new double[][]{{-40,-30},{-40,-20},{-8,-20},{-8,-30}});
    objetos[3].setCorBlue(1);
    objetos[3].setFilhos(new int[]{4} );
    
    objetos[4].setNome("Objeto1.4");
    objetos[4].setVertice(new double[][]{{-30,-20},{-30,-10},{-10,-10},{-10,-20}});
    objetos[4].setCorBlue(1);
    objetos[4].setCorRed(1);
    objetos[4].setFilhos(new int[]{5});
    
    objetos[5].setNome("Objeto1.5");
    objetos[5].setVertice(new double[][]{{-20,-10},{-20,-6},{10,-6},{10,-10}});
    objetos[5].setCorGreen(1);
    objetos[5].setCorBlue(1);
    
    objetos[6].setNome("Objeto2");
    objetos[6].setVertice(new double[][]  {{80,-40},{120,-40},{120,0},{80,0},{100,30},{120,0}});
    objetos[6].setCorGreen(0.5);
  }
  
  public void populaCombo()
  {
    for(int i=0; i < nrObjetos; i++)
    {
      cbxListObjetos.addItem(objetos[i].getNome());
    }
  }

public void montaHierarquia(int indiceNodoPai)
  {
    for(int i = 0; i < objetos[indiceNodoPai].getfilhos().length;i++)
    {
          indiceObjetos = objetos[indiceNodoPai].getfilhos()[i];

gl.glPopMatrix();
    }
  }
  
  public void display()
  {
     indiceObjetos = 0;
       
    //Limpando buffers
    gl.glClear(GL_COLOR_BUFFER_BIT|GL_DEPTH_BUFFER_BIT);
    //define o modo da matriz
    gl.glMatrixMode(GL_MODELVIEW);
    //Inicializa esse modo
    gl.glLoadIdentity();
    //Projeção ortogonal   
    gl.glOrtho(-200,200,200,-200,-200,200);

gl.glPushMatrix();
        gl.glTranslated(objetos[indiceObjetos].getTranslateX(),objetos[indiceObjetos].getTranslateY(),0);
        gl.glScaled(objetos[indiceObjetos].getScalaX(),objetos[indiceObjetos].getScalaY(),0);
        gl.glRotated(objetos[indiceObjetos].getAngulo(),objetos[indiceObjetos].getRotateX(),objetos[indiceObjetos].getRotateY(),objetos[indiceObjetos].getRotateZ());
        montaHierarquia(0);
      gl.glPopMatrix();
  }
  
  public void desenha()
  {
      double aux[][] = objetos[indiceObjetos].getVertice();
      if(aux == null)
         return;
      gl.glBegin(GL_POLYGON);
      for(int i = 0 ; i < aux.length ; i++)
      {
        gl.glColor3d(objetos[indiceObjetos].getCorRed() ,objetos[indiceObjetos].getCorGreen(),objetos[indiceObjetos].getCorBlue());
        gl.glVertex2d(aux[i][0],aux[i][1]);
      }
    gl.glEnd();
  }
}

Explicações sobre a segunda classe:
O método public void iniciaObjetos(), cria os objetos e seta suas propriedades como o nome do objeto, os vértices dos objetos(vértices como em uma matriz, pois a tela é formada pr pontos cada ponto destes tem uma coordenada (x,y) que são os vertices), as core RGB de cada objeto e também quem são os filhos deste objeto.
Definição de filhos: Se um dedo é filho de uma mão, então se eu mexer a minha mão o meu dedo ira se movimentar juntamete. E se eu movimentar o meu dedo, não influenciara nada em minha mão.

O método public void populaCombo() popula o combo com todos os objetos que existem em meu ambiente OpenGl.

O método public void montaHierarquia(int indiceNodoPai) recebe como parâmetro um inteiro que seria o índice do nodo pai. Com isso ele monta a hierarquia dos objetos e os desenha na tela.

public void montaHierarquia(int indiceNodoPai)
  {
    //Vai de 0 até o número de filhos deste pai que foi passado por parâmetro.
    for(int i = 0; i < objetos[indiceNodoPai].getfilhos().length;i++)
    {
          indiceObjetos = objetos[indiceNodoPai].getfilhos()[i];
       // Abre a chave da hierarquia dos  objetos
       gl.glPushMatrix();
         //Criado para gerar os movimentos de translação 
         gl.glTranslated(objetos[indiceObjetos].getTranslateX(),objetos[indiceObjetos].getTranslateY(),0);
         //Criado para gerar os movimentos de mudança de escala
         gl.glScaled(objetos[indiceObjetos].getScalaX(),objetos[indiceObjetos].getScalaY(),0);
       //Criado para gerar os movimentos de rotação   gl.glRotated(objetos[indiceObjetos].getAngulo(),objetos[indiceObjetos].getRotateX(),objetos[indiceObjetos].getRotateY(),objetos[indiceObjetos].getRotateZ());
          //Chama a função para desenhar o objeto na tela
         desenha();        
        if(objetos[indiceObjetos].getfilhos().length != 0)
          montaHierarquia(indiceObjetos);
         //Fecha a chave da hierarquia do objeto,
        gl.glPopMatrix();
    }
  }

De maneira mais simples para montar a hierarquia:

Montando dessa forma, a cena é pai do filho1 e do filho dois, isto pois o filho1 e o filho2 foram criados dentro do Push e do Pop da cena. Então se eu realizar uma transformação na cena, esta operação influenciará nos filhos também.
O método public void display()é onde é passado para ficar redesenhando a cena. Neste método é passado a cada repaint que é realizado na tela.
O método public void desenha() desenha os objetos na tela, com sua determinada cor e coordenada.

A terceira classe é a classe do JFrame, ou JInternalFrame que ira chamar a animação do OpenGl.

comentários: 1

Tópicos Relacionados

Cubo 3d?
É possivel criar grandes jogos em java???
OpenGL - reformular funcoes
Exemplos de Open Gl !
Open GL
Qual Library para criar em 2D ?
OpenGL4 for Java
Java e OpenGL
Um defensor de Java ajudando a destruir o java :(