//Imports up here
public class ArtLabAppletLaunch extends Applet implements ActionListener {
   private static final long serialVersionUID = 1L;
   
   protected GLCanvas canvas;
   protected Animator animator;
   //Listener's/Handlers for input
   private KeyboardHandler keyboardHandler = new KeyboardHandler();
   //GUI for Applet
   private TextArea descriptionTxt = new TextArea(); 
   private Button backToGalleryBtn = new Button();
   //Load Canvas stuff?
   private ArtLab artLabProcess = new ArtLab(this);
   //GUI
   private Panel movePnl = new Panel();
   private Label[] controlLbl = new Label[5];
   private Button scaleHeightPlusBtn = new Button();
   private Button scaleHeightLessBtn = new Button();
   private Button scaleWidthPlusBtn = new Button();
   private Button scaleWidthLessBtn = new Button();
   private Button zoomInBtn = new Button();
   private Button zoomOutBtn = new Button();
   private Button resetBtn = new Button();
   
   public void addKeyListener(KeyboardListenerInterface listener){
        keyboardHandler.addListener(listener);
   }
   
   public void changeText(String text){
      descriptionTxt.setText(text);
   }
   
   public void setGalleryGUIVisibility(boolean visible){
      backToGalleryBtn.setVisible(visible);
      movePnl.setVisible(visible);
   }
   
   public void init() {
      //setSize(512, 256 + 128 + 32 + 128); this is commented out
      setLayout(new BorderLayout());
      GLCapabilities glCapabilities = new GLCapabilities();
      
      glCapabilities.setDoubleBuffered(true);
      glCapabilities.setHardwareAccelerated(true);

      canvas = new GLCanvas(glCapabilities);
      
      setLayout(null);
      
      animator = new Animator(canvas);
      
      canvas.addGLEventListener(keyboardHandler);
        canvas.addKeyListener(keyboardHandler);
        
      canvas.addGLEventListener(artLabProcess);
      
      canvas.setBounds(0, 0, 512, 256);
      
      backToGalleryBtn.setBounds(0, 384, 512, 32); 
      backToGalleryBtn.setLabel("~ Go Back To The Art Gallery ~"); 
      backToGalleryBtn.setVisible(false);
      
      descriptionTxt.setBounds(0, 256, 512, 128);
      //GUI PANEL for looking Directions
      movePnl.setVisible(false);
      movePnl.setBounds(0, 417, 512, 128);
      movePnl.setLayout(null);
         controlLbl[0] = new Label();
         controlLbl[0].setBounds(0, 0, 64, 32);
         controlLbl[0].setText("Height: ");
         movePnl.add(controlLbl[0]);
            scaleHeightPlusBtn.setBounds(64, 0, 32, 32);
            scaleHeightPlusBtn.setLabel("+");
            movePnl.add(scaleHeightPlusBtn);
            
            scaleHeightLessBtn.setBounds(128, 0, 32, 32);
            scaleHeightLessBtn.setLabel("-");
            movePnl.add(scaleHeightLessBtn);
         //More boring GUI adding code
            
      //Add All GUI to Applet
      add(canvas);
      add(descriptionTxt);
      //more GUI added here
      
      //Add Event Listeners for all GUI
      backToGalleryBtn.addActionListener(this);
      //More of those
   }
   
   public void start() {
      animator.setRunAsFastAsPossible(false);
      animator.start();
   }

   public void stop() {
      animator.stop();
   }
   
   public void actionPerformed(ActionEvent unknownEvent){
      //Handles GUI actions
   }
}

public class ArtLab implements GLEventListener{
   private float LOOK_AT_DIST = 100.0f;
   private final static float FOV = 45.0f;
   private final static float DEFAULT_ART_SIZE = 10.0f;
   private final static float CAMERA_MOVEMENT_INCREMENT = 0.2f;
   private GL gl;
   private GLU glu = new GLU();
   
   //Camera Points
   private Point3D CameraLook = new Point3D(0.0f, 1.0f, 0.0f);
   private Point3D Camera = new Point3D(5.0f, 5.0f, 10.0f,  0,270,0);

   private Point3D standAloneCamera = standAloneCameraReset;
   
   //Gallery Objects
   private LinkedList <Plane> walls = new LinkedList <Plane> ();
   private Plane floor = null;
   private Plane ceiling = null;
   private LinkedList <Art> artThumbNails = new LinkedList <Art> ();
   
   //Stand-alone art Object
   private Art standAlone = null;
   
   //Huds
   private HeadsUpDisplay cursor = new HeadsUpDisplay(0.50f, 0.50f, 0.064f, 0.128f);
   
   //Display Lists
   private int room;
   private int art;
   
   //TOP
   private ArtLabAppletLaunch artLabTOP;

   //Application Variables
   private int lastSelectedImage = -1, galleryImage = -1;
   private boolean inGallery = true;
   private boolean hasResetCamera = false;
   
   public ArtLab(ArtLabAppletLaunch cg) { 
       cg.addKeyListener(new KeyboardListenerInterface() {
          public void buttonPressed(int i){handleKeyboardInput(i);}
       });
       
       artLabTOP = cg;
   } 
   
   public void init(GLAutoDrawable drawable) {
       gl = drawable.getGL(); //Set Up GL
       gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);//Black GL clear color
       gl.glEnable(GL.GL_DEPTH_TEST);
       gl.glClearDepth(1.0f);
       gl.glDepthFunc(GL.GL_LEQUAL);
       gl.glHint(GL.GL_PERSPECTIVE_CORRECTION_HINT, GL.GL_NICEST);
       
       //Initialize Camera
       updateCamera();
       
       //Create Room Environment
       walls.add(new Plane(15f, 5.0f, 0f,
            30.0f, 10.0f, 0.0f));
       walls.add(new Plane(15f, 5.0f, 30f,
            30.0f, 10.0f, 0.0f));
       walls.add(new Plane(0f, 5.0f, 15f,
            0.0f, 10.0f, 30.0f));
       walls.add(new Plane(30f, 5.0f, 15f,
            0.0f, 10.0f, 30.0f));
       floor = new Plane(15f, 0.0f, 15f,
            30.0f, 0.0f, 30.0f);
       ceiling = new Plane(15f, 10.0f, 15f,
            30.0f, 0.0f, 30.0f);
       
       //Create Paintings
       artThumbNails.add(new Art(15f, 5.0f, 0.2f,
            5.0f, 4.5f, 0.0f));
       //etc
       
       //Create Stand-Alone Art
       standAlone = new Art(0.0f, 5.0f, 0f,
            5.0f, 5.0f, 0.0f);
       
       //Load Images

       //Load Textures From Images
       
       //Create Display List's
       room = gl.glGenLists(1);
       art = gl.glGenLists(2);
       
       //Populate Room Display List
       gl.glNewList(room, GL.GL_COMPILE);
          //Draw Walls
          for(int index = 0; index < walls.size(); index++){
             gl.glPushMatrix();
                gl.glTranslatef(walls.get(index).X, walls.get(index).Y, walls.get(index).Z);
                walls.get(index).draw(gl);
             gl.glPopMatrix();
          }
         //Draw Floor
         gl.glPushMatrix();
            gl.glTranslatef(floor.X, floor.Y, floor.Z);
            floor.draw(gl);
         gl.glPopMatrix();
         //Draw Ceiling
         gl.glPushMatrix();
            gl.glTranslatef(ceiling.X, ceiling.Y, ceiling.Z);
            ceiling.draw(gl);
         gl.glPopMatrix();
       gl.glEndList();
       
     //Populate Art Display List
       gl.glNewList(art, GL.GL_COMPILE);
       //Draw Art in Canvas's
          for(int index = 0; index < artThumbNails.size(); index++){
             gl.glPushMatrix();
                gl.glTranslatef(artThumbNails.get(index).X, artThumbNails.get(index).Y,artThumbNails.get(index).Z);
                artThumbNails.get(index).draw(gl);
             gl.glPopMatrix();
          }
       gl.glEndList();
    } 
   
   public void reshape(GLAutoDrawable drawable, int x, int y, int width, int height) {
      GL gl = drawable.getGL();
      if (height == 0){height = 1;} //Avoid Division by Zero Error
      
      gl.glViewport(x, y, width, height);
      gl.glMatrixMode(GL.GL_PROJECTION);
      gl.glLoadIdentity();
      glu.gluPerspective(FOV, (float)width/(float)height, 1, LOOK_AT_DIST); 

      gl.glMatrixMode(GL.GL_MODELVIEW);
      gl.glLoadIdentity();
   }
   
   public void display(GLAutoDrawable drawable) {
      GL gl = drawable.getGL();
      gl.glClear(GL.GL_COLOR_BUFFER_BIT | GL.GL_DEPTH_BUFFER_BIT);
      gl.glLoadIdentity();

      if(inGallery){
         //Use In Gallery Camera
         glu.gluLookAt(Camera.X, Camera.Y, Camera.Z,
               CameraLook.X, CameraLook.Y, CameraLook.Z, 0,1,0); 
         //Environment
         gl.glCallList(room);
         gl.glCallList(art);
         //Heads Up Displays
         begin2D();
            gl.glPushMatrix();
               cursor.draw(gl);
            gl.glPopMatrix();
         end2D();
      } else {
         //Use Solo Art Viewing Camera
         glu.gluLookAt(standAloneCamera.X, standAloneCamera.Y, standAloneCamera.Z,
               CameraLook.X, CameraLook.Y, CameraLook.Z, 0,1,0);
         //Environment for Viewing Single Art-work
         gl.glPushMatrix();
            gl.glTranslatef(standAlone.X, standAlone.Y, standAlone.Z);
            standAlone.drawBigArt(gl);
         gl.glPopMatrix();
      }
      
       gl.glFlush();
   }
   
    private void begin2D() {
        gl.glMatrixMode(GL.GL_PROJECTION);        
        gl.glPushMatrix();        
           gl.glLoadIdentity();        
           gl.glOrtho(0.0f, 0.0f, 1.0f, 1.0f, -1.0f, 1.0f);        
           gl.glMatrixMode(GL.GL_MODELVIEW);        
              gl.glPushMatrix();        
                 gl.glLoadIdentity();        
                 gl.glDisable(GL.GL_DEPTH_TEST);        
                 gl.glDisable(GL.GL_LIGHTING);
    }
    
    private void end2D() {
                gl.glEnable(GL.GL_LIGHTING);
                gl.glEnable(GL.GL_DEPTH_TEST);
                gl.glMatrixMode(GL.GL_PROJECTION);
             gl.glPopMatrix();
          gl.glMatrixMode(GL.GL_MODELVIEW);
        gl.glPopMatrix(); 
    }
   
}

<applet code="org.jdesktop.applet.util.JNLPAppletLauncher" width=480 height=320
      archive="http://download.java.net/media/applet-launcher/applet-launcher.jar,
               http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jar,
               http://download.java.net/media/gluegen/webstart/gluegen-rt.jar,
               http://caseykneale.000space.com/ArtLaboratory.jar">
   <param name="codebase_lookup" value="false">
   <param name="subapplet.classname" value="ArtLabAppletLaunch">
   <param name="subapplet.displayname" value="ArtLab - Casey Kneale">
   <param name="noddraw.check" value="true">
   <param name="progressbar" value="true">
   <param name="jnlpNumExtensions" value="1">
   <param name="jnlpExtension1" value="http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp">
</applet>

<applet code="org.jdesktop.applet.util.JNLPAppletLauncher" width=480 height=320
      archive="http://download.java.net/media/applet-launcher/applet-launcher.jar,
               http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jar,
               http://download.java.net/media/gluegen/webstart/gluegen-rt.jar,
               http://caseykneale.000space.com/gallery2.jar">
   <param name="codebase_lookup" value="false">
   <param name="subapplet.classname" value="ArtLabAppletLaunch">
   <param name="subapplet.displayname" value="ArtLab - Casey Kneale">
   <param name="noddraw.check" value="true">
   <param name="progressbar" value="true">
   <param name="jnlpNumExtensions" value="1">
   <param name="jnlpExtension1" value="http://download.java.net/media/jogl/builds/archive/jsr-231-webstart-current/jogl.jnlp">
</applet>

glu.gluLookAt(Camera.X, Camera.Y, Camera.Z,
            CameraLook.X, CameraLook.Y, CameraLook.Z,
            1,0,0); 

glu.gluLookAt(Camera.X, Camera.Y, Camera.Z,
            CameraLook.X, CameraLook.Y, CameraLook.Z,
            0,1,0); 

       private Point3D Camera = new Point3D(0.0f, 16.0f, 0.0f);
private Point3D CameraLook = new Point3D(0.0f, 00.0f, 0.0f);

//Start point of Wall line
Vector2D collisionV1 = new Vector2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
//End point of Wall line
Vector2D collisionV2 = new Vector2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
            
//Create Line Vector
Vector2D surfaceVector = collisionV2.sub(collisionV1);
            
//Start point of intersecting line
Vector2D velocityVector1 = ballBehavior.toVector2D();
//End Point of the intersecting line
Vector2D velocityVector2 = ballBehavior.movePointForward(10f).toVector2D();
//Create Line Vector
Vector2D velocityVector = velocityVector2.sub(velocityVector1);
            
//Normalize the two surface vector
surfaceVector = surfaceVector.normalize();
            
//Get the Normal by flipping the X and Y
Vector2D normal = new Vector2D( surfaceVector.Y, surfaceVector.X);
            
float vectorX = surfaceVector.dotProduct(surfaceVector, velocityVector);
float vectorY = surfaceVector.dotProduct(normal, velocityVector);
//Make the VectorY negative as to "flip" the collision
vectorY = -vectorY;
                     
Vector2D mathVector = normal.mul(vectorY);//To simplify the final operation
Vector2D bouncedVector = surfaceVector.mul(vectorX).add(mathVector);
                     
//Place on Object on the Point of the reflection
reflect = new Point2D(bouncedVector.X, bouncedVector.Y);
   

public class Vector2D {
    public float X = 0.0f, Y = 0.0f;

    public Vector2D() {}
    public Vector2D( float x, float y ) { X = x; Y = y; }
    public Vector2D( Vector2D a ) { X = a.X; Y = a.Y; }
    
    public float length() {
        return (float) Math.sqrt( (X * X) + (Y * Y) );
    }

    public Vector2D normalize(){
        float len = length();
        if (len > 0f || len < 0f) {
            X /= len;
            Y /= len;
        }
        return new Vector2D(X, Y);
    }
    
    public float dotProduct( Vector2D A, Vector2D B) {                       
        return (A.X * B.X) + (A.Y * B.Y);
    }

    public Vector2D add( Vector2D a ) {
        X += a.X;
        Y += a.Y;
        return new Vector2D(X, Y);
    }
    
    public Vector2D sub( Vector2D a ) {
        X -= a.X;
        Y -= a.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( Vector2D a ) {
        X *= a.X;
        Y *= a.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( float scalar ) {
        X *= scalar;
        Y *= scalar;
        return new Vector2D(X, Y);
    }
    
}

if(intersectionPoint.X != 0f && intersectionPoint.Y != 0f){//If Lines Intersect
      //Start point of Wall line
      Vector2D collisionV1 = new Vector2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
      //End point of Wall line
      Vector2D collisionV2 = new Vector2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
      //Subtract the two wall vectors
      Vector2D surfaceVector = collisionV2.sub(collisionV1);
      //Normalize the two wall vectors
      surfaceVector = surfaceVector.normalize();
            
      //Get the Normal 
      Vector2D normal = new Vector2D( surfaceVector.Y, -surfaceVector.X);
            
      //Start point of intersecting line
      Vector2D velocityVector1 = ballBehavior.toVector2D();
      //End Point of the intersecting line
      Vector2D velocityVector2 = ballBehavior.movePointForward(10f).toVector2D();
            
      float vectorX = surfaceVector.dotProduct(surfaceVector, velocityVector1);
      float vectorY = surfaceVector.dotProduct(normal, velocityVector2);
      //Make the VectorY negative as to "flip" the collision
      vectorY =  -vectorY;
            
      Vector2D bouncedVector = surfaceVector.mul(vectorX).add(normal.mul(vectorY));
            
      //Place on Object on the Point of the reflection
      reflect = new Point2D(bouncedVector.X, bouncedVector.Y);
   }

if(intersectionPoint.X != 0f && intersectionPoint.Y != 0f){//If Lines Intersect
   System.out.println("Collision Has Occured!");
   //Start point of Wall line
   Vector2D collisionV1 = new Vector2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
   //End point of Wall line
   Vector2D collisionV2 = new Vector2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
   //Subtract the two wall vectors
   Vector2D surfaceVector = collisionV2.sub(collisionV1);
   //Normalize the two wall vectors
   surfaceVector = surfaceVector.normalize();
            
   //Get the Normal
   Vector2D normal = new Vector2D( ( surfaceVector.Y * -1), surfaceVector.X);
            
   //Start point of intersecting line
   Vector2D velocityVector1 = ballBehavior.toVector2D();
   //End Point of the intersecting line
   Vector2D velocityVector2 = ballBehavior.movePointForward(10f).toVector2D();
   float vectorX = surfaceVector.dotProduct(surfaceVector, velocityVector1);
   float vectorY = surfaceVector.dotProduct(surfaceVector, velocityVector2);
   //Make the VectorY negative as to "flip" the collision
   vectorY = -vectorY;
            
   Vector2D mathVector = normal.mul(vectorY);//To simplify the final operation
   Vector2D bouncedVector = surfaceVector.mul(vectorX).add(mathVector);
            
   //Place on Object on the Point of the reflection
   endPoint.X = bouncedVector.X;
   endPoint.Z = bouncedVector.Y;
}

public class Vector2D {
    public float X = 0.0f, Y = 0.0f;
    public float velocity = 1.0f;
    
    public Vector2D() {}
    public Vector2D( float x, float y ) { X = x; Y = y; }
    public Vector2D( Vector2D a ) { X = a.X; Y = a.Y; }
    
    public float length() {
        return (float) Math.sqrt( (X * X) + (Y * Y) );
    }

    public Vector2D normalize(){
        float len = length();
        if (len > 0f || len < 0f) {
            X /= len;
            Y /= len;
        }
        return new Vector2D(X, Y);
    }
    
    public float dotProduct(Vector2D A, Vector2D B) {                       
        return (A.X * B.X) + (A.Y * B.Y);
    }

    public Vector2D add( Vector2D a ) {
        X += a.X;
        Y += a.Y;
        return new Vector2D(X, Y);
    }
    
    public Vector2D sub( Vector2D a ) {
        X -= a.X;
        Y -= a.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( Vector2D vec ) {
        X *= vec.X;
        Y *= vec.Y;
        return new Vector2D(X, Y);
    }

    public Vector2D mul( float scalar ) {
        X *= scalar;
        Y *= scalar;
        return new Vector2D(X, Y);
    }
    
}

public class Point2D {
   public float X = 0f, Y = 0f;//Point Locations
   public float angle = 0f;//Point Rotations
      
   public Point2D(float x, float y){X = x; Y = y;}
      
   public Point2D(float x, float y, float angleIn)
      {X = x; Y = y; angle = angleIn;}
      
   public Point2D(){};
      
   public Point2D movePointForward(float distance){
      Point2D newPoint = new Point2D();
      double tmpAngle = Math.toRadians(angle);
      newPoint.X = (float)(Math.cos(tmpAngle) * distance) + X;
      newPoint.Y = (float)(Math.sin(tmpAngle) * distance) + Y;
      newPoint.angle = angle;
      return newPoint;
   }
   
   public static float dotProduct(Point2D A, Point2D B) {                       
        return A.X * B.X + A.Y * B.Y;
    }

    public float magnitude() {
        return (float) Math.sqrt(X * X + Y * Y); 
    }

    public void normalize() {
        float M = magnitude();
        if (M > 0f || M < 0f) {
            X /= M;
            Y /= M;
        }
    }
   
   
   public void wrapAngle(){angle = wrapValue(angle, 360.0f);}
   
   public float wrapValue(float in, float max){return in % max;}
}

   public void handleKeyboardInput(int ki){
      if(ki == KeyEvent.VK_SPACE){
         Point2D intersectionPoint = lineIntersectionTest();
         if(intersectionPoint != null){
            System.out.println(intersectionPoint.X + "\n" + intersectionPoint.Y);
            endPoint.X = intersectionPoint.X;
            endPoint.Z = intersectionPoint.Y;
            //Now I have the points of collision on the line
         }
         
      }
   }

   public Point2D lineIntersectionTest(){
      double intersectionX, intersectionY;
      Point2D Line1P1 = ballBehavior;
      Point2D Line1P2 = ballBehavior.movePointForward(10f);
      
      Point2D Line2P1 = new Point2D(wall.X - (wall.Width/2), wall.Z - (wall.Depth/2));
      Point2D Line2P2 = new Point2D(wall.X + (wall.Width/2), wall.Z - (wall.Depth/2));
      
      double denominator, numeratorA, numeratorB, r, s;

      denominator =  ( ( Line2P2.Y - Line2P1.Y ) * ( Line1P2.X - Line1P1.X ) ) -
                  ( ( Line2P2.X - Line2P1.X ) * ( Line1P2.Y - Line1P1.Y ) );
   
      //if(denominator != 0){ //check for parrellel lines
      numeratorA = ( ( Line2P2.X - Line2P1.X) * (Line1P1.Y - Line2P1.Y ) ) -
                ( ( Line2P2.Y - Line2P1.Y) * (Line1P1.X - Line2P1.X ) );

      numeratorB = ( (Line1P2.X - Line1P1.X ) * ( Line1P1.Y - Line2P1.Y) ) -
                ( (Line1P2.Y - Line1P1.Y ) * ( Line1P1.X - Line2P1.X) );

      r = ( numeratorA / denominator ) ;
       s = ( numeratorB / denominator ) ;

       if(r >= 0.0f && r <= 1.0f  &&
          s >= 0.0f && s <= 1.0f){
          intersectionX = r * (Line1P2.X - Line1P1.X) + Line1P1.X;
           intersectionY = r * (Line1P2.Y  - Line1P1.Y) + Line1P1.Y;
           return new Point2D((float) intersectionX, (float) intersectionY);
       }
       
       return new Point2D();
   }