joglframe.java

Demo for OJGL: JOGLframe.java

import java.io.*;
import java.awt.*;
import java.awt.event.*;
import javax.media.opengl.*;
import javax.media.opengl.glu.*;
import com.sun.opengl.util.*; // GLUT, FPSAnimator

public class JOGLframe extends Frame
  implements GLEventListener
{
  /////////////////////// main ///////////////////////

  public static void main(String[] args) {
    JOGLframe frame = new JOGLframe();
  }

  //////////////// Variables /////////////////////////

  // Viewing Window Frame size.
  int width = 500;
  int height = 400;
  final boolean enableFullscreen = false;
  final boolean hideCursor = true;

  // Global canvas for event handling.
  GLCanvas canvas;

  // GUT and GLUT are global objects so that
  // they do not have to be newed in each frame.
  GLUT glut = new GLUT();
  GLU glu = new GLU();

  // Vars for animation.
  FPSAnimator animator;

  // Functionality from local modules.
  View view = new View();
  Fullscreen fullscreen = new Fullscreen();
  InputDevice inputDevice = new InputDevice();
//   DrawingBasics drawingBasics = new DrawingBasics();
//   StipplePattern stipplePattern = new StipplePattern();
//   Bezier bezier = new Bezier();
//   Light light = new Light();
//   Blend blend = new Blend();
//   GLUdemo gludemo = new GLUdemo();
//   GLUTdemo glutdemo = new GLUTdemo();
//   SolarSystem solarSystem = new SolarSystem( animator, light );
//   Imaging imaging = new Imaging();
//   Font font = new Font();
//   Texturing texturing = new Texturing();

  ///////////////// Functions /////////////////////////

  public JOGLframe()
    {
      super("JOGL in an AWT Frame");

      // Use all scrren for this frame
      // in case fullscreen does not work.
      if( enableFullscreen ) {
	width = fullscreen.getWidth();
	height = fullscreen.getHeight();
      }
      setSize( width, height );
      setFocusable( true );
      if( enableFullscreen ) { 
	fullscreen.init( this ); }

      if( hideCursor ) { inputDevice.hideCursor( this ); }

      setLayout(new BorderLayout());

      initJOGL();

      addWindowListener( new WindowAdapter() {
	  public void windowClosing( WindowEvent e ) {
	    exit(); } });
      
      setVisible( true );
      requestFocus();
      canvas.requestFocusInWindow();
      pack();
    }


  private void initJOGL()
    {
      GLCapabilities caps = new GLCapabilities();
      caps.setDoubleBuffered( true );
      caps.setHardwareAccelerated( true );

      canvas = new GLCanvas( caps );
      canvas.addGLEventListener( this );

      add( canvas, BorderLayout.CENTER );

      // UserEventListener is tied to this canvas.
//       UserEventMediator listener = new UserEventMediator
// 	( this, inputDevice, view, light, canvas );
//       canvas.addKeyListener( listener );
//       canvas.addMouseListener( listener );
//       canvas.addMouseMotionListener( listener );

      // Canvas gets focus whenever frame is activated.
      addWindowListener( new WindowAdapter() {
	  public void windowActivated( WindowEvent e ) {
	    canvas.requestFocusInWindow(); } } );

      animator = new FPSAnimator( canvas, 20 );
      animator.setRunAsFastAsPossible( false );
      animator.start();
    }

  
  ////////// Methods defined by GLEventListener ///////////

  public void init( GLAutoDrawable drawable )
    {
      GL gl = drawable.getGL();

      drawable.setGL( new DebugGL(drawable.getGL() ));
      System.out.println("Init GL is " + gl.getClass().getName());

      // On some systems the reshape call does not seem to 
      // happen automatically on init.
      // Set the projection and viewport.
      reshape( drawable, 0, 0, width, height );

      gl.glClearColor( 0f, 0f, 0f, 0.0f );
      //gl.glClearColor( 1f, 1f, 1f, 0.0f );

      // GL.GL_FRONT[_AND_BACK], GL.GL_LINE, GL.GL_FILL
      gl.glPolygonMode( GL.GL_FRONT_AND_BACK, GL.GL_FILL );

      gl.glEnable( GL.GL_DEPTH_TEST );
      //gl.glDepthFunc(GL.GL_LEQUAL);
      gl.glEnable( GL.GL_AUTO_NORMAL );
      //gl.glEnable(GL.GL_NORMALIZE);
      //gl.glShadeModel( GL.GL_FLAT );
      gl.glShadeModel( GL.GL_SMOOTH );

//       blend.init( gl );
//       light.init( gl );
//       font.init( gl );      
//       solarSystem.initDisplayLists( gl, glu );
//       imaging.init( width, height );
//       imaging.loadImage( null ); // Load default image.
//       texturing.init( gl );
    }


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

      GL gl = drawable.getGL();

      gl.glMatrixMode(GL.GL_PROJECTION);
      gl.glLoadIdentity();

      gl.glFrustum( -0.1f, 0.1f, -0.1f, 0.1f, 0.2f, 20.0f );
      //glu.gluOrtho2D(0f, (float)width, 0f, (float)height );
      //gl.glOrtho(0, 1, 0, 1, -1, 1);
      //gl.glOrtho(-1.0f, 1.0f, 1.0f, -1.0f, 0.0f, 10.0f );

      // If we do not have a rectangular viewport and 
      // want to avoid distortion we have to adjust
      // the viewing volume to the viewport.
      //
      double aspect = (double)width / (double)height;
      // Field ov view in y direction [0..180].
      final double fovy = 30.0f;
      //glu.gluPerspective( fovy, aspect, 1.2f, 20.0f );

      gl.glViewport( 0, 0, width, height );
    }


  public void displayChanged( GLAutoDrawable drawable, 
			      boolean modeChanged, 
			      boolean deviceChanged ) 
    { 
      System.out.println ("displayChanged()");
    }


  public void display(GLAutoDrawable drawable)
    {
      //System.out.println("display");//ddd
      GL gl = drawable.getGL();

      // Clear Framebuffer and Z-Buffer.
      gl.glClear( GL.GL_COLOR_BUFFER_BIT | 
		  GL.GL_DEPTH_BUFFER_BIT );
      // Default color.
      gl.glColor3f(1f, 1f, 1f);
      //gl.glColor3f(0f, 0f, 0f);

      gl.glMatrixMode(GL.GL_MODELVIEW);
      gl.glLoadIdentity();
	
      // Viewing Transformation.
      view.setCamera( gl );
      //setCameraLookAt( glu );

      // Model Transformation and Draw Content.
      drawSomething( gl );

      //getAndPrintError( gl );

      gl.glFlush();

      //imaging.saveFrameAsPNG( gl, null );
    }

  /////////////////// Error and Exit //////////////////

  int getAndPrintError( GL gl ) 
    {
      int errorCode = gl.glGetError();
      //String errorStr = new String();
      //errorStr = glu.gluErrorString( errorCode );
      //String errorStr = glu.gluErrorString( GL.GL_OUT_OF_MEMORY );
      //System.out.println( errorStr );
      //errorStr = gl.glGetString(GL.GL_PROGRAM_ERROR_STRING_ARB);
      System.out.println( errorCode );
      return errorCode;
    }

  // Called via user event and on window closing.
  void exit()
    {
      animator.stop();
      if( enableFullscreen ) { fullscreen.exit(); }
      System.exit( 0 ); 
    }

  /////////////////////// Drawings ////////////////////

  private void drawSomething( GL gl ) 
    {
      
//       drawingBasics.drawPoints( gl );
//       drawingBasics.draw2DPoints( gl );
//       drawingBasics.drawTriangle( gl );
//       drawingBasics.drawWhiteTriangle( gl );
//       drawingBasics.drawHouse( gl );
//       drawingBasics.drawCircle( gl, 0f, 0f, 0f );
//       drawingBasics.drawHouseNoInnerEdge( gl );
//       drawingBasics.drawCube( gl, 1.0f );
//       drawingBasics.drawAxis( gl, true );

      //stipplePattern.drawStippledPolygon( gl );

//      blend.drawColredCircles( gl );
//      blend.drawBlendPlane( gl, bezier );  

//       bezier.drawSpiral( gl );
//       bezier.draw2DBezier( gl );
//       bezier.draw3DBezier( gl );
//       ////bezier.drawNURBS( gl, glu ); // not yet.

      //gludemo.draw( gl, glu );
      //glutdemo.draw( gl, glut );
      //glutdemo.drawTeaPotWithLight( gl, glut );

      //solarSystem.draw( gl, glu );

      //light.animate( gl, glu, glut );
      //light.setSomeWhiteMaterial( gl );

      //imaging.draw( gl );
      
      //font.draw( gl );

      //texturing.draw( gl );

    }

}