//jleblanc: 2.27.06
//rudimentry exploration of branching

import org.lwjgl.opengl.*;
import org.lwjgl.opengl.glu.GLU;
import org.lwjgl.input.Keyboard;

public class tree {
    private boolean done = false;
    private final String windowTitle = "Basic OpenGL App";
    private DisplayMode displayMode;
 	float rotation = 0f;

    //Main function just creates and runs the application.
    public static void main(String args[]) {
    	tree app = new tree();
        app.run();
    }

    //Initialize the app, then sit in a render loop until done==true.
    public void run() {
        try {
            init();
            while (!done) {
                mainloop();
                render();
                Display.update();

            }
            cleanup();
        }
        catch (Exception e) {
            e.printStackTrace();
            System.exit(0);
        }
    }

 
    //Initialize the environment
    private void init() throws Exception {
        initDisplay();
        initGL();
    }


    //Create an OpenGL display, in this case a fullscreen window.
    private void initDisplay() throws Exception {
        // set to full screen, no chrome
        Display.setFullscreen(false);
        // get all possible display resolutions
        DisplayMode d[] = Display.getAvailableDisplayModes();
        // find a resolution we like
        for (int i = 0; i < d.length; i++) {
            if (d[i].getWidth() == 800
                && d[i].getHeight() == 600
                && d[i].getBitsPerPixel() == 32) {
                displayMode = d[i];
                break;
            }
        }
        // set the display to the resolution we picked
        Display.setDisplayMode(displayMode);
        Display.setTitle(windowTitle);
        // create the window
        Display.create();
    }


    //Initialize OpenGL
    private void initGL() {
        // Select the Projection Matrix (controls perspective)
        GL11.glMatrixMode(GL11.GL_PROJECTION);
        GL11.glLoadIdentity();    // Reset The Projection Matrix

        // Define perspective
        GLU.gluPerspective(
            45.0f,        // Field Of View
            (float)displayMode.getWidth() / (float)displayMode.getHeight(), // aspect ratio
            0.1f,         // near Z clipping plane
            100.0f);      // far Z clipping plane

        // Where is the 'eye'
        GLU.gluLookAt(
            -.5f, 2f, 7f,    // eye position //-.5,1,7
            //0f,0f,15f,
            0f, 0f, 0f,    // target to look at
            0f, 1f, 0f);   // which way is up

        // Select The Modelview Matrix (controls model orientation)
        GL11.glMatrixMode(GL11.GL_MODELVIEW);
        
        // depth
        GL11.glEnable(GL11.GL_DEPTH_TEST);
    }


    //Handle keyboard input.  Just check for escape key or user
    private void mainloop() {
        if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {   // Escape is pressed
            done = true;
        }
        if(Display.isCloseRequested()) {                // Window is closed
            done = true;
        }
    }

    //Render the scene.
    private void render()
    {
     	rotation += .08f;
        // Clear screen and depth buffer
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
        // Reset the Modelview matrix
        // this resets the coordinate system to center of screen
        GL11.glLoadIdentity();       
		// rotate coord system around Y
		GL11.glRotatef(rotation, 0,1,0);
		
		GL11.glTranslatef(0, -.5f, 0);
        // draw crosshairs
        //drawOrigin();
        //draw tree
		rendertree(rotation/3, .05f, 1, 1, 10);
		GL11.glRotatef(120, 1,0,0);
		rendertree(rotation/3, .05f, 1, 1, 10);
		GL11.glRotatef(120, 1,0,0);
		rendertree(rotation/3, .05f, 1, 1, 10);
    }
   
    public void rendertree(float turn, float width, float scale, float level, float maxlevel)
    {
        if(level<maxlevel)
        {
        		//SET COLOR
        	    //GL11.glColor3f(.5f+level/10,1f-level/10,level/6);//Yellow
        	    GL11.glColor3f(.5f+level/10,0,1-level/10);//Yellow
        		
        	    //PLACE CURRENT ELEMENT
        	    GL11.glTranslatef(0, .5f*scale, 0);
        	    renderCube(width, scale, width);
        	    GL11.glTranslatef(0, .5f*scale, 0);
        	    
        	    //PRODUCE 3D effect
        	    //Cool if comment out this but not its inverse
        	    GL11.glRotatef(turn, 0,1,0);
        	    
        	    //Branch 1
        	    GL11.glRotatef(turn, 1,0,0);
        		rendertree(turn, width-.005f, scale*.7f, level+1, maxlevel);
        		//Branch 2
        		GL11.glRotatef(-2*turn, 1,0,0);
        		rendertree(-1*turn, width-.005f, scale*.7f, level+1, maxlevel);
        		
        		//UNDO Transformations
        		GL11.glRotatef(turn, 1,0,0);
        		GL11.glRotatef(-1*turn, 0,1,0);//NOT NEEDED
        		GL11.glTranslatef(0, -1*scale, 0);
        }
    	
    }
      
    public void drawOrigin() {
        // draw origin 
    	GL11.glColor3f(.5f, .5f, .5f);
        GL11.glLineWidth(1);
        GL11.glBegin(GL11.GL_LINE_STRIP); 
	    	GL11.glVertex3f( -1f, 0f, 0f);        // left
	    	GL11.glVertex3f( 1f, 0f, 0f);         // right
    	GL11.glEnd(); 
    	GL11.glBegin(GL11.GL_LINE_STRIP); 
	    	GL11.glVertex3f( 0f, -1f, 0f);        // bottom
	    	GL11.glVertex3f( 0f, 1f, 0f);         // top
    	GL11.glEnd(); 
    	GL11.glBegin(GL11.GL_LINE_STRIP); 
			GL11.glVertex3f( 0f, 0f, -1f);        // far
			GL11.glVertex3f( 0f, 0f, 1f);         // near
		GL11.glEnd(); 
		GL11.glBegin(GL11.GL_LINE_STRIP); 
			GL11.glVertex3f( -1f, 0f, 1f);        // left near
			GL11.glVertex3f( 1f, 0f, 1f);         // rite near
			GL11.glVertex3f( 1f, 0f, -1f);        // rite far
			GL11.glVertex3f( -1f, 0f, -1f);       // left far
			GL11.glVertex3f( -1f, 0f, 1f);        // left near (close)
		GL11.glEnd(); 
    }
    

    //Draw a 1x1x1 cube centered at the origin
    public void renderCube(float scalex, float scaley, float scalez)
    {
        GL11.glPushMatrix();
		{
    	GL11.glScalef(scalex,scaley,scalez);
        GL11.glBegin(GL11.GL_QUADS);
        // Front Face
        GL11.glVertex3f(-.5f, -.5f,  .5f);	// Bottom Left
        GL11.glVertex3f( .5f, -.5f,  .5f);	// Bottom Right
        GL11.glVertex3f( .5f,  .5f,  .5f);	// Top Right
        GL11.glVertex3f(-.5f,  .5f,  .5f);	// Top Left
        // Back Face
        GL11.glVertex3f(-.5f, -.5f, -.5f);	// Bottom Right
        GL11.glVertex3f(-.5f,  .5f, -.5f);	// Top Right
        GL11.glVertex3f( .5f,  .5f, -.5f);	// Top Left
        GL11.glVertex3f( .5f, -.5f, -.5f);	// Bottom Left
        // Top Face
        GL11.glVertex3f(-.5f,  .5f, -.5f);	// Top Left
        GL11.glVertex3f(-.5f,  .5f,  .5f);	// Bottom Left
        GL11.glVertex3f( .5f,  .5f,  .5f);	// Bottom Right
        GL11.glVertex3f( .5f,  .5f, -.5f);	// Top Right
        // Bottom Face
        GL11.glVertex3f(-.5f, -.5f, -.5f);	// Top Right
        GL11.glVertex3f( .5f, -.5f, -.5f);	// Top Left
        GL11.glVertex3f( .5f, -.5f,  .5f);	// Bottom Left
        GL11.glVertex3f(-.5f, -.5f,  .5f);	// Bottom Right
        // Right face
        GL11.glVertex3f( .5f, -.5f, -.5f);	// Bottom Right
        GL11.glVertex3f( .5f,  .5f, -.5f);	// Top Right
        GL11.glVertex3f( .5f,  .5f,  .5f);	// Top Left
        GL11.glVertex3f( .5f, -.5f,  .5f);	// Bottom Left
        // Left Face
        GL11.glVertex3f(-.5f, -.5f, -.5f);	// Bottom Left
        GL11.glVertex3f(-.5f, -.5f,  .5f);	// Bottom Right
        GL11.glVertex3f(-.5f,  .5f,  .5f);	// Top Right
        GL11.glVertex3f(-.5f,  .5f, -.5f);	// Top Left
        GL11.glEnd();
		}
        GL11.glPopMatrix();
        
        //NOTE: In some ways easier to do the push/pop for this part
        //RESCALE
        //GL11.glScalef(1/scale,1/scale,1/scale);
    }
    

    //Cleanup all the resources.
    private void cleanup() {
        Display.destroy();
    }
}