import glmodel.GL_Mesh;
import glmodel.GL_Triangle;

import java.nio.*;  // Native IO buffers: LWJGL uses these to efficiently exchange data with system memory

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

/*
 * 
 */

public class Sawako_Surface02 {
    private boolean done = false;
    
    private boolean culf = false;
    private boolean rot = true;
    private boolean rot2 = true;
    
    private final String windowTitle = "::ribbon flower::";
    private DisplayMode displayMode;
    float rotation = 0;
    float rotation2 = 0;

    // camera position and rotation (see handleNavigationKeys())
    float[] cameraPos = new float[] {-1,0,4};
    float cameraRotation = 0f;
    final float piover180 = 0.0174532925f;// A constant used in navigation
    
    private GL_Mesh obj;
    private GL_Mesh obj2;
    private GL_Mesh obj3;
    
   
   /////////////////basic settings///////////////////
    public static void main(String args[]) {
    	Sawako_Surface02 app = new Sawako_Surface02();
        app.run();
    }

    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();
        
        obj = new GL_Mesh();
        sphereMesh();
        obj.rebuild();
        obj.regenerateNormals();
        
        obj2 = new GL_Mesh();
        sphereMesh02();
        obj2.rebuild();
        obj2.regenerateNormals();
        
        obj3 = new GL_Mesh();
        sphereMesh03();
        obj3.rebuild();
        obj3.regenerateNormals();
    }

    
    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();
    }

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

        // Define perspective
        GLU.gluPerspective(
            65.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(
            -1f, 0f, 4f,   // eye position
            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);
        
        // make sure OpenGL correctly layers objects
        GL11.glEnable(GL11.GL_DEPTH_TEST);
        
        // OpenGL won't draw backward facing triangles ("back faces")
        GL11.glDisable(GL11.GL_CULL_FACE);
        
        // set the background color
        GL11.glClearColor(.8f, .8f, .83f, 0.8f);
        
        // blending
        GL11.glEnable(GL11.GL_BLEND);
        GL11.glBlendFunc(GL11.GL_SRC_ALPHA, GL11.GL_ONE_MINUS_SRC_ALPHA); 
        
        // Force normals to length 1
        GL11.glEnable(GL11.GL_NORMALIZE);
        
    }

/////////////////////////key issue/////////////////////////////
    private void mainloop() {
        if(Keyboard.isKeyDown(Keyboard.KEY_ESCAPE)) {   // Escape is pressed
            done = true;
        }
        if(Display.isCloseRequested()) {                // Window is closed
            done = true;
        }
        
        if(Keyboard.isKeyDown(Keyboard.KEY_SPACE)){
        culf = !culf;
        }
        if(Keyboard.isKeyDown(Keyboard.KEY_R)){
            rot = !rot;
            }
        if(Keyboard.isKeyDown(Keyboard.KEY_T)){
            rot2 = !rot2;
            }
       
//      Handle key press events (down/up)
        handleKeyPressEvents();
        // Handle arrow keys (press and hold) 
        handleNavigationKeys();
    }

    
//  ----------------------------------------------------------------
    // Keyboard event handlers
    //----------------------------------------------------------------
    
   
    public void handleKeyPressEvents()
    {
        while ( Keyboard.next() )  {
        	if (Keyboard.getEventKeyState()) {
                keyDown(Keyboard.getEventKey());
            }
            else {
                keyUp(Keyboard.getEventKey());
            }
        }    	
    }
    
    
    public void handleNavigationKeys()
    {
        // Turn left
        if (Keyboard.isKeyDown(Keyboard.KEY_LEFT)) {
            cameraRotation += 0.3f;
        }
        // Turn right
        if (Keyboard.isKeyDown(Keyboard.KEY_RIGHT)) {
            cameraRotation -= 0.3f;
        }
        // move forward in current direction
        if (Keyboard.isKeyDown(Keyboard.KEY_UP)) {
            cameraPos[0] -= (float) Math.sin(cameraRotation * piover180) * 0.3f;
            cameraPos[2] -= (float) Math.cos(cameraRotation * piover180) * 0.3f;
        }
        // move backward in current direction
        if (Keyboard.isKeyDown(Keyboard.KEY_DOWN)) {
            cameraPos[0] += (float) Math.sin(cameraRotation * piover180) * 0.3f;
            cameraPos[2] += (float) Math.cos(cameraRotation * piover180) * 0.3f;
        }
        // move camera down
        if (Keyboard.isKeyDown(Keyboard.KEY_PRIOR)) {
            cameraPos[1] +=  .3f;
        }
        // move camera up
        if (Keyboard.isKeyDown(Keyboard.KEY_NEXT)) {
            cameraPos[1] -=  .3f;
        }
    }

    
///////////////////////Render the scene///////////////////////////
    private void render() {
    	
    	if(rot = true){
    		rotation += .02f;	
    	}else{
    		rotation = 0f;
    	}
    	
    	if(rot2 = true){
    		rotation2 += .1f;	
    	}
    
    	
        GL11.glClear(GL11.GL_COLOR_BUFFER_BIT | GL11.GL_DEPTH_BUFFER_BIT);
        GL11.glLoadIdentity();
        GL11.glRotatef(rotation2, 0,1,0);
        // make depth buffer read-only before drawing translucent objects
        GL11.glDepthMask(false); 
        
        
        GL11.glPushMatrix();
        {
        	
        	  // Place the 'camera'
			GLU.gluLookAt(	// camera position
							cameraPos[0], cameraPos[1], cameraPos[2],
							// look at a point directly in front of camera
							cameraPos[0]- (float) Math.sin(cameraRotation* piover180), cameraPos[1],
							cameraPos[2]- (float) Math.cos(cameraRotation* piover180),
							// which way is up
							0f, 1f, 0f);

        	if(culf == true){
        		GL11.glDisable(GL11.GL_CULL_FACE);
        	}else{
        		GL11.glEnable(GL11.GL_CULL_FACE);
        	}
			
        	float sc1 = (1f + (float)(Math.sin(rotation)))/2f+0.2f;
        	GL11.glScalef(.82f*sc1, .82f*sc1, .82f*sc1);
        	renderMesh(obj, 0);
        	//renderMesh(obj3, 0);
        	
        	float sc2 = (1f + (float)(Math.sin(rotation-0.01f)))*3f;
        	GL11.glScalef(15.82f+sc2, 15.82f+sc2, 15.82f+sc2);
        	renderMesh(obj3, 0);
        	
        	float sc3 = ((float)(Math.sin(rotation-0.015f)))*5f;
        	GL11.glScalef(30.82f+sc2, 30.82f+sc2, 30.82f+sc2);
        	renderMesh(obj2, 0);
        	
        }
        GL11.glPopMatrix();   
        GL11.glDepthMask(true); 
    }


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


 ///////////////////sphere algorithm//////////////////////  
       
    public void sphereMesh() {
        
	    int countTri = 0;
    	int reso = 15;

    	  for(int u=0; u<reso; u++){
    	    for(int v=0; v<reso; v++){
    	    	
    	  	GL11.glColor4f(0.8f+random(0.2f),0.6f,0.7f+random(.3f),0.1f+random(0.3f));
    	    	
    	   /* 	if(countTri <= 9){ GL11.glColor4f(0.0f, 0.8f, 0.0f, 0.9f);}
    	    	else if(countTri <= 18){GL11.glColor4f(0.8f,0.0f, 0.0f, 0.8f);}
    	    	else{GL11.glColor4f(random(0.6f),0.0f,random(0.8f),0.15f);} */
    	    	
    	      float xx = (float) ((2 + Math.sin(Math.PI*2*u/reso)*Math.sin(Math.PI*2*v/reso))*Math.sin(Math.PI*3*v/reso));
    	      float yy = (float) ((2 + Math.sin(Math.PI*2*u/reso)*Math.sin(Math.PI*2*v/reso))*Math.cos(Math.PI*3*v/reso));
    	      float zz = (float) (Math.cos(Math.PI*2*u/reso)*Math.sin(Math.PI*2*v/reso) + (4*v/reso) - 2);

    	      float xx2 = (float) ((2 + Math.sin(Math.PI*2*(u-1)/reso)*Math.sin(Math.PI*2*(v-1)/reso))*Math.sin(Math.PI*3*(v-1)/reso));
    	      float yy2 = (float) ((2 + Math.sin(Math.PI*2*(u-1)/reso)*Math.sin(Math.PI*2*(v-1)/reso))*Math.cos(Math.PI*3*(v-1)/reso));
    	      float zz2 = (float) (Math.cos(Math.PI*2*(u-1)/reso)*Math.sin(Math.PI*2*(v-1)/reso) + (4*(v-1)/reso) - 2);

    	      float xx3 = (float) ((2 + Math.sin(Math.PI*2*(u+1)/reso)*Math.sin(Math.PI*2*(v+1)/reso))*Math.sin(Math.PI*3*(v+1)/reso));
    	      float yy3 = (float) ((2 + Math.sin(Math.PI*2*(u+1)/reso)*Math.sin(Math.PI*2*(v+1)/reso))*Math.cos(Math.PI*3*(v+1)/reso));
    	      float zz3 = (float) (Math.cos(Math.PI*2*(u+1)/reso)*Math.sin(Math.PI*2*(v+1)/reso) + (4*(v+1)/reso) - 2);
    	        
    	        obj.addVertex(xx, yy, zz);
    	        obj.addVertex(xx2, yy2, zz2);
    	        obj.addVertex(xx3, yy3, zz3);
    	        
    	        obj.addTriangle(countTri, countTri+1, countTri+2);
    	        countTri = countTri + 3;
    	        
    	        System.out.println(countTri);
    	        
    	        
    	     }
    	   }
    	
  
}
    
    
    /////////////////////////////
    
 public void sphereMesh02() {
        
	 int countTri = 0;
    	
	  for(float s=0; s<2*Math.PI; s+=0.2){
		  for(float t= -1.6f; t<1.6; t+=0.05){
    	    	
    	  	GL11.glColor4f(0.2f+random(0.4f),random(0.20f),0.4f+random(0.2f),0.1f+random(0.30f));
    	    	
    	  	float s2 = s - 0.2f;
    	  	float t2 = t - 0.05f;
    	  	float s3 = s + 0.2f;
    	  	float t3 = t + 0.05f;
    	  	
    	  	float xx = (float)(Math.cos(s) + t*Math.cos(s/2)*Math.cos(s));
    	  	float yy= (float)(Math.sin(s)+t*Math.cos(s/2)*Math.sin(s));
    	  	float zz= (float)(t*Math.sin(s/2));
    	  	
    		float xx2 = (float)(Math.cos(s2) + t*Math.cos(s2/2)*Math.cos(s2));
    	  	float yy2 = (float)(Math.sin(s2)+t*Math.cos(s2/2)*Math.sin(s2));
    	  	float zz2 = (float)(t2*Math.sin(s2/2));
    	  	
    		float xx3 = (float)(Math.cos(s3) + t*Math.cos(s3/2)*Math.cos(s3));
    	  	float yy3 = (float)(Math.sin(s3)+t*Math.cos(s3/2)*Math.sin(s3));
    	  	float zz3 = (float)(t3*Math.sin(s3/2));
    	      
    	  	obj2.addVertex(xx, yy, zz);
	        obj2.addVertex(xx2, yy2, zz2);
	        obj2.addVertex(xx3, yy3, zz3);
	        
	        obj2.addTriangle(countTri, countTri+1, countTri+2);
	        countTri = countTri + 3;
    	        
    	     }
    	   }
    	
  
}
 
 /////////////////////////
 
 public void sphereMesh03() {
     
	 int countTri = 0;
 	
	 for(float u=(float) (-1*Math.PI); u<Math.PI; u+=0.1){
		    for(float v=(float) (-1*Math.PI); v<Math.PI; v+=0.1){
   	    	
		float u1 = u - 0.1f;
		float v1 = v - 0.1f;
		float u2 = u + 0.1f;
		float v2 = v + 0.1f;
		    	
   	  	GL11.glColor4f(random(0.6f),1.0f,0.0f,0.2f+random(0.30f));
   	    	
   	 float xx = (float)(2*Math.sin(3*u) / (2 + Math.cos(v)));
   	float yy = (float)(2*(Math.sin(u) + 2*Math.sin(2*u)) / (2 + Math.cos(v + 2 * Math.PI / 3)));
   	float zz = (float)((Math.cos(u) - 2*Math.cos(2*u))*(2 + Math.cos(v))*(2 + Math.cos(v + 2* Math.PI / 3)) / 4);
   	  	
 	 float xx2 = (float)(2*Math.sin(3*(u1)) / (2 + Math.cos(v1)));
    	float yy2 = (float)(2*(Math.sin(u1) + 2*Math.sin(2*(u1))) / (2 + Math.cos((v1) + 2 * Math.PI / 3)));
    	float zz2 = (float)((Math.cos(u1) - 2*Math.cos(2*(u1)))*(2 + Math.cos(v1))*(2 + Math.cos((v1) + 2* Math.PI / 3)) / 4);
  
    	 float xx3 = (float)(2*Math.sin(3*(u2)) / (2 + Math.cos(v2)));
        	float yy3 = (float)(2*(Math.sin(u2) + 2*Math.sin(2*(u2))) / (2 + Math.cos((v2) + 2 * Math.PI / 3)));
        	float zz3 = (float)((Math.cos(u2) - 2*Math.cos(2*(u2)))*(2 + Math.cos(v2))*(2 + Math.cos((v2) + 2* Math.PI / 3)) / 4);
         
        	obj3.addVertex(xx, yy, zz);
	        obj3.addVertex(xx2, yy2, zz2);
	        obj3.addVertex(xx3, yy3, zz3);
	        
	        obj3.addTriangle(countTri, countTri+1, countTri+2);
	        countTri = countTri + 3;
   	        
   	     }
   	   }
   	
 
}
 
    
 ////////////////////render mesh//////////////////////
 public void renderMesh(GL_Mesh o, int textureHandle)
 {
     GL_Triangle t;
     GL11.glBindTexture(GL11.GL_TEXTURE_2D,textureHandle);
     GL11.glBegin(GL11.GL_TRIANGLES);
     for (int j = 0; j < o.triangles.length; j++) { // draw all triangles in object
         t = o.triangles[j];

         GL11.glTexCoord2f(t.uvw1.x, t.uvw1.y);
         GL11.glNormal3f(t.norm1.x, t.norm1.y, t.norm1.z);
         GL11.glVertex3f( (float)t.p1.pos.x, (float)t.p1.pos.y, (float)t.p1.pos.z);

         GL11.glTexCoord2f(t.uvw2.x, t.uvw2.y);
         GL11.glNormal3f(t.norm2.x, t.norm2.y, t.norm2.z);
         GL11.glVertex3f( (float)t.p2.pos.x, (float)t.p2.pos.y, (float)t.p2.pos.z);

         GL11.glTexCoord2f(t.uvw3.x, t.uvw3.y);
         GL11.glNormal3f(t.norm3.x, t.norm3.y, t.norm3.z);
         GL11.glVertex3f( (float)t.p3.pos.x, (float)t.p3.pos.y, (float)t.p3.pos.z);
     }
     GL11.glEnd();
 }

 
 public void renderMeshNormals(GL_Mesh o)
 {
     GL_Triangle t;
     GL11.glDisable(GL11.GL_LIGHTING);
     GL11.glColor3f(0,1,0);
     GL11.glBegin(GL11.GL_LINES); 
     {
	        for (int j = 0; j < o.triangles.length; j++) { // draw all triangles in object
	            t = o.triangles[j];
		            GL11.glVertex3f( (float)t.p1.pos.x, (float)t.p1.pos.y, (float)t.p1.pos.z);
		            GL11.glVertex3f( (float)(t.p1.pos.x+t.norm1.x), (float)(t.p1.pos.y+t.norm1.y), (float)(t.p1.pos.z+t.norm1.z));
		
		            GL11.glVertex3f( (float)t.p2.pos.x, (float)t.p2.pos.y, (float)t.p2.pos.z);
		            GL11.glVertex3f( (float)(t.p2.pos.x+t.norm2.x), (float)(t.p2.pos.y+t.norm2.y), (float)(t.p2.pos.z+t.norm2.z));
		
		            GL11.glVertex3f( (float)t.p3.pos.x, (float)t.p3.pos.y, (float)t.p3.pos.z);
		            GL11.glVertex3f( (float)(t.p3.pos.x+t.norm3.x), (float)(t.p3.pos.y+t.norm3.y), (float)(t.p3.pos.z+t.norm3.z));
	        }
     }
     GL11.glEnd();
     GL11.glEnable(GL11.GL_LIGHTING);
 }


    
    ////////////////////key up and down/////////////////
    
    public void keyDown(int keycode) {
        // Normals off/on
     //   if (keycode == Keyboard.KEY_N) {
     //       normalsOn = !normalsOn;
     //   }
    }

    public void keyUp(int keycode) {
    }
    
    ///////////////random generater////////////////////
    public static float random(float upperbound) {
    	return (float)Math.random()*((float)upperbound);
    }

}