Tutorial 01 :
Setting up your Java Environment with GL4Java

package org.jouvieje.gl4java.Container;

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

import org.jouvieje.gl4java.tutorials.Tutorial1;

//Gl4java import
import gl4java.awt.GLAnimCanvas;

public class FrameContainer extends JFrame
{
    GLAnimCanvas glScene = null;
   
    public FrameContainer(String titre)
    {
        super(titre);
       
        getContentPane().setLayout(new BorderLayout());
        setDefaultCloseOperation(EXIT_ON_CLOSE);
        pack();
        setSize(640, 480);
        setLocationRelativeTo(null);     //position the frame in the screen center
       
        /**
         * Creates our scene and add it in the frame
         */
        glScene = new Tutorial1(getSize().width, getSize().height);
        getContentPane().add(glScene, BorderLayout.CENTER);
       
        start();
    }
   
    public void start()
    {
        //start the OpenGl scene
        glScene.start();
       
        //attempt to get the focus of the canvas
        glScene.requestFocus();
    }
   
    public void stop()
    {
        //stop the OpenGl scene
        glScene.stop();
    }
   
    public void destroy()
    {
        //stop the OpenGl scene and destroy it
        glScene.stop();
        glScene.cvsDispose();
    }
}

package org.jouvieje.gl4java.Container;

import java.awt.*;
import javax.swing.JApplet;

import org.jouvieje.gl4java.tutorials.Tutorial1;

import gl4java.awt.GLAnimCanvas;

public class AppletContainer extends JApplet
{
    //our scene
    GLAnimCanvas glScene = null;
   
    /*
     * Initialisation of the Applet
     */
    public void init()
    {
        //creates a layout to add our scene in the center an fit to the Applet
        setLayout(new BorderLayout());
        setSize(640, 480);
       
        /*
         * Create our OpenGl scene and add it in the applet
         */
        glScene = new Tutorial1(getSize().width, getSize().height);
        //add it to the applet
        add(glScene, BorderLayout.CENTER);
    }
   
    /*
     * Start of the applet
     */
    public void start()
    {
        //start the OpenGl scene
        glScene.start();
       
        //attempt to get the focus of the scene
        glScene.requestFocus();
    }
   
    /*
     * Stop of the applet
     */
    public void stop()
    {
        //stop the OpenGl animation
        glScene.stop();
    }
   
    /*
     * Destruction of the Applet
     */
    public void destroy()
    {
        //stop the OpenGl scene and destroy it
        glScene.stop();
        glScene.cvsDispose();
    }
}

package oorg.jouvieje.gl4java.tutorials;

import java.awt.event.*;

import gl4java.awt.GLAnimCanvas;

public class Tutorial1 extends GLAnimCanvas implements KeyListener, MouseMotionListener
{
    //contain the key pressed
    private boolean[] keys = new boolean[256];
   
    private float zOffset = -5.0f;
   
    public Tutorial1(int w, int h)
    {
        super(w, h);
       
        /*
         * Register events listener
         *
         * Remember, the MouseListener does not be added (it is already added
         * in GLAnimCanvas)
         */
        this.addKeyListener(this);
        this.addMouseMotionListener(this);
       
        //seemed to be essential to get any performance
        setAnimateFps(60);
    }
   
    /****************************
     *    The reshape method    *
     ****************************************************************************
     * This method is called at each resize event of the OpenGl component.      *
     *                                                                          *
     * It resize the Viewport of the scene and set the Viewing Volume           *
     ****************************************************************************/
    public void reshape(int width, int height)
    {
        /*
         * First, we use two objects of GLAnimCanvas : gl ad glu
         * - gl provides access to OpenGl functionality and graphics card extension
         * - glu provides access to OpenGl utility library routine
         */
        System.out.println("Width : "+width+" Height: "+height);
        if(height <= 0)
            height = 1;
       
        /*
         * Set the current Viewport region
         * The Viewport is the region of the window in which the scene is drawn
         *
         * Here: all the space
         */
        gl.glViewport(0, 0, width, height);
       
        /*
         * Select the Projection matrix stack.
         * This matrix contain the information related to how the scene is drawn on the
         * screen.
         * Here, we begin to reset it and set the Viewing Volume
         * The viewing volume defines a 3D space in which the scene is drawn
         * (see the Tutorial 19 for more details on the Viewing Volume)
         */
        gl.glMatrixMode(GL_PROJECTION);                             //Select the Projection matrix
        gl.glLoadIdentity();                                        //Reset the current matrix
        glu.gluPerspective(45.0f, width / height, 0.1f, 1000.0f);   //set the Viewing Volume
       
        /*
         * Select the Modelview matrix stack.
         * This matrix contains the differents transformations like the translation, rotation,
         * scale...
         * We only reset the matrix.
         *
         * In the drawing methods, the current matrix is the last selected. So the matrix is
         * the Modelview matrix.
         */
        gl.glMatrixMode(GL_MODELVIEW);    //select The Modelview Matrix
        gl.glLoadIdentity();              //set the ModalView matrix to identity
    }
   
    //Call just before that the GL-Context is create
    public void preInit()
    {
        //Double buffered drawing enabled
        doubleBuffer = true;
        //I DON'T KNOW WHAT IS STEREOVIEW !!!
        stereoView = false;
    }
   
    /*************************
     *    The init method    *
     ***********************************************************
     * This is called just after the GL-Context is create      *
     *                                                         *
     * This method is used to :                                *
     * - activate some modes like texture, light ...           *
     * - affect value to properties                            *
     * - import testures, load your data ...                   *
     ***********************************************************/
    public void init()
    {
        /*
         * Enables the Smooth color shading mode to create graduate color
         * The effect can be shown on the Pyramid of the Tutorial 04
         */
        gl.glShadeModel(GL_SMOOTH);
        /*
         * Defines the clearing color in RGB mode (Red Green Blue)
         * This color is the background color of the scene.
         * Components must be a float number in the interval [0,1]
         * Here: R=0, G=0, B=0 so the color is black
         * (r=1, G=1, B=1 is the white color)
         *
         * Rem: the last value is the Alpha components (also called RGBA).
         * We should show its effects in the Blending tutorial (09)
         */
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
       
        /*
         * The Depth buffer
         * This buffer keeps tracks the depth of each points of the scene.
         * This buffer, when an object is drawn, tests if the object
         * is behind or in front of the objects already drawn.
         * GL_LEQUAL test if the current object to be drawn is closer
         * or as the same distance than
         */
        gl.glClearDepth(1.0);             //Enable Clearing of the Depth buffer
        gl.glDepthFunc(GL_LEQUAL);        //Type of Depth test
        gl.glEnable(GL_DEPTH_TEST);       //Enable Depth Testing
       
        //Define the correction done to the perspective calculation (perspective looks a it better)
        gl.glHint(GL_PERSPECTIVE_CORRECTION_HINT, GL_NICEST);
    }
   
    /*******************************
     *    Draw the OpenGl scene    *
     *******************************************************************
     * Here we place all the code related to the drawing of the scene. *
     * This method is called by the drawing loop (the display method)  *
     *******************************************************************/
    public void drawGlScene()
    {
        /*
         * We begin to clear the color and the depth buffer and reset the view.
         * After, we translate the repere axis to the back. This is used to view
         * the scene : Remember to call something like that !
         */
        gl.glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);    //Clear the buffers
        gl.glLoadIdentity();                                      //Reset the view
        gl.glTranslatef(0.0f, 0.0f, zOffset);                     //Translate the scene backwards
       
        /***********************
         * THE DRAWING IS HERE *
         ********************************************
         * We will see that in futur tutoriaux.     *
         ********************************************/
       
        processEvents();
    }
   
    /**********************
     *    Display loop    *
     *******************************************************************
     * This method is the drawing loop, it calls                       *
     *******************************************************************/
    public void display()
    {
        if(!glj.gljMakeCurrent())    //Ensure GL is initialised correctly
        return;
       
        //draw the scene
        drawGlScene();
       
        /*
         * Swap buffers
         * By using double-buffering, the scene is entirely drawn in a buffer
         * out of the screen. After the drawing is finish, the buffers are
         * permutated to print the scene instantly in the screen.
         */
        glj.gljSwap();
        glj.gljCheckGL();       //Check for errors
        glj.gljFree();          //release GL
    }
   
                /*The events*/
   
    /****************************
     *    Process the events    *
     *******************************************************************
     * Put here all the events related to a key or a mouse pressed.   *
     *******************************************************************/
    public void processEvents()
    {
        /*
         * Put here all related OpenGl effects of the events
         *
         * How put the events here:
         * Just because if you would call an OpenGl method in on of
         * the key or mouse method, it do not work !
         *
         * Ex: in the Tutorial 04, the call: gl.glShadeModel(...)
         * could not be placed on an event method.
         */
    }
   
                /*Key events*/
   
    public void keyReleased(KeyEvent ke)
    {
        switch(ke.getKeyCode())
        {
            //close the application with the escape key
            case KeyEvent.VK_ESCAPE: System.exit(0); break;
        }
    }
    public void keyPressed(KeyEvent ke){}
    public void keyTyped(KeyEvent ke){}
   
                /*Mouse events*/
   
    public void mouseEntered(MouseEvent me)
    {
        if(me.getComponent().equals(this))
            requestFocus();
    }
    public void mouseExited(MouseEvent me){}
    public void mouseClicked(MouseEvent me){}
    public void mousePressed(MouseEvent me){}
    public void mouseReleased(MouseEvent me){}
   
    public void mouseMoved(MouseEvent me){}
    public void mouseDragged(MouseEvent me){}
}