animação usando JOGL

[]s

/**
 *
 * @author Simone
 */
import com.sun.opengl.util.Animator;
import java.awt.Frame;
import java.awt.event.KeyEvent;
import java.awt.event.KeyListener;
import java.awt.event.WindowAdapter;
import java.awt.event.WindowEvent;
import java.util.logging.Level;
import java.util.logging.Logger;
import javax.media.opengl.*;
import javax.media.opengl.glu.*;
import com.sun.opengl.util.GLUT;


public class ExemploAnimacao implements GLEventListener, KeyListener {
    
    // Atributos
    private GL gl;
    private GLU glu;
    private GLUT glut;
    private float velocidade = 0.0f;
    private float v = 0.1f;
    private Animator a; //para controlar a Thread de animacao
    private boolean running = false;


    public static void main(String[] args) {
        Frame frame = new Frame("Exemplo Animação");
        
        GLCanvas canvas = new GLCanvas();

        canvas.addGLEventListener(new ExemploAnimacao());
        frame.add(canvas);
        //define o tamanho da janela de visualizacao
        frame.setSize(400, 400);
        
        final Animator animator = new Animator(canvas);
        
        
        frame.addWindowListener(new WindowAdapter() {
            @Override
            public void windowClosing(WindowEvent e) {
                // Run this on another thread than the AWT event queue to
                // make sure the call to Animator.stop() completes before
                // exiting
                new Thread(new Runnable() {

                    public void run() {
                        animator.stop();
                        System.exit(0);
                    }
                }).start();
            }
        });
        // Center frame
        frame.setLocationRelativeTo(null);
        frame.setVisible(true);
        animator.start();
    }
    
    public void init(GLAutoDrawable drawable) {
        // Interface para as funcoes OpenGL
        gl = drawable.getGL();
        glu = new GLU();
        
        //Informacoes da placa gráfica
        System.err.println("INIT GL IS: " + gl.getClass().getName());
        System.err.println("GL_VENDOR: " + gl.glGetString(GL.GL_VENDOR));
        System.err.println("GL_RENDERER: " + gl.glGetString(GL.GL_RENDERER));
        System.err.println("GL_VERSION: " + gl.glGetString(GL.GL_VERSION));

        //Especifica que a cor para limpar a janela de visualizacao eh branca
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
        
        gl.glMatrixMode(GL.GL_PROJECTION);
        gl.glOrtho(-100.0, 100.0, -100.0, 100.0, -100.0, 100.0);
        gl.glMatrixMode(GL.GL_MODELVIEW);
        
        gl.glEnable(GL.GL_DEPTH_TEST);
        
        //inicializa a thread com o objeto drawable
        a = new Animator(drawable);

        /* add the key listener */
        drawable.addKeyListener(this);
    }

    public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
        System.out.println("reshape " + width + " " + height);
    }

    public void display(GLAutoDrawable drawable) {
        gl = drawable.getGL();
        glut = new GLUT();

        // Limpa a janela de visualizacao com a cor de fundo especificada
        gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);       
        
        // Reset the current matrix to the "identity"
        gl.glLoadIdentity();
        
        //modifica angulo de rotacao
        gl.glRotatef(velocidade, 0.0f, 1.0f, 1.0f);
        gl.glColor3f(0.0f, 0.5f, 1.0f);
        torus(glut);
    
        // Executa os comandos OpenGL
        gl.glFlush();
    }

    //Desenha um toroide na cena
    public void torus(GLUT glut){
        glut.glutWireTorus(30,60,30,30);
    }
    
    //método que implementa o incremento do angulo de rotacao e da velocidade de rotacao
    public void animador()
    {
        velocidade += v;
        if (velocidade > 360)
            velocidade -= 360.0;
    }

    //Método que estabelece os critérios de animação
    public void animar( boolean turnOnOff)
    {
         new Thread(new Runnable() {
             public void run() {
                 while(true)
                 {
                     
                    //faz a velocidade incrementar ou decrementar
                    animador();
                    try {
                        Thread.sleep(20); // sleep a bit
                    } catch (InterruptedException ex) {
                        Logger.getLogger(ExemploAnimacao.class.getName()).log(Level.SEVERE, null, ex);
                    }
                    //verifica se running for false / para a animação senão executa a animação
                    if(!running)
                        break;
                 }
                 
             }
         }).start(); //fim da construção da thread
         
         if(turnOnOff)
         {
                 //inicia a thread
                 a.start();
                 System.out.println("animando?? " + a.isAnimating());
         }
         else
               //para a thread
               a.stop();
    }
    
    public void displayChanged(GLAutoDrawable drawable, boolean modeChanged, boolean deviceChanged) { }
    
    // Metodos requeridos para a implementacao do KeyListener
    public void keyPressed(KeyEvent e){
    	System.out.println("Key pressed");
    	switch (e.getKeyChar()) {
            case KeyEvent.VK_ESCAPE:  /*  Escape Key */
    		/* exit */
    		System.exit(0);
    		break;
            
            case 'r':
                System.out.println("chamou Rotação");
                //ang += 45.0f;
                break;
                
            case '+':
                System.out.println("aumenta velocidade: " + v);
                v += 0.1f;
                break;
            
            case '-':
                System.out.println("diminui velocidade: " + v);
                v -= 0.1f;
                break;
                
            case 'a':
                //se a thread não estiver em execução - chamar animar com true e 
                //modificar o valor de running para true
                if(!a.isAnimating())
                {
                    System.out.println("inicia Animação");
                    animar(true);
                    running = true;    
                }
                break;
                
            case 'p':
                if(a.isAnimating())
                {
                    System.out.println("Para Animação");
                    animar(false);
                    running = false;
                }
                break;
        }
        
    }
    public void keyReleased(KeyEvent e){}
    public void keyTyped(KeyEvent e){}

}