package com.example.opgl002;

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.app.Activity;
import android.opengl.GLSurfaceView;
import android.opengl.GLSurfaceView.Renderer;
import android.opengl.GLU;
import android.os.Bundle;
import android.util.Log;

//--------------------------------------------------------以下貼上

public class MainActivity extends Activity {
	 private GLSurfaceView glSurfaceView;  
	 private TriangleRenderer renderer;
	 
    @Override
    protected void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);
       
        glSurfaceView = new GLSurfaceView(this);
        renderer = new TriangleRenderer();
        glSurfaceView.setRenderer((Renderer) renderer);
        setContentView(glSurfaceView);    
    }
 
    
    @Override
    protected void onResume() {
      super.onResume();
      glSurfaceView.onResume();
    }
   
    @Override
    protected void onPause() {
      super.onPause();
      glSurfaceView.onPause();
    }
   
    
	//private GLSurfaceView mGLView;
}

class TriangleRenderer implements Renderer {

	   Triangle triangle = new Triangle();    
        
	   private float angleTriangle = 0.0f; // (NEW)
//	   private float angleQuad = 0.0f;     // (NEW)
	   private float speedTriangle = 2.0f; // (NEW)
//	   private float speedQuad = -0.4f;    // (NEW)	   

	 @Override
	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		Log.v("GREATCAT", "onSurfaceCreated");	

	      gl.glClearColor(0.0f, 0.0f, 0.0f, 1.0f);  // Set color's clear-value to black
	      gl.glClearDepthf(1.0f);            // Set depth's clear-value to farthest
	      gl.glEnable(GL10.GL_DEPTH_TEST);   // Enables depth-buffer for hidden surface removal
	      gl.glDepthFunc(GL10.GL_LEQUAL);    // The type of depth testing to do
	      gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);  // nice perspective view
	      gl.glShadeModel(GL10.GL_SMOOTH);   // Enable smooth shading of color
	      gl.glDisable(GL10.GL_DITHER);      // Disable dithering for better performance
	}
	@Override
	public void onSurfaceChanged(GL10 gl, int width, int height) {
//		Log.v("GREATCAT", "onSurfaceChanged");
	      if (height == 0) height = 1;   // To prevent divide by zero
	      float aspect = (float)width / height;
	   
	      // Set the viewport (display area) to cover the entire window
	      gl.glViewport(0, 0, width, height);
	  
	      // Setup perspective projection, with aspect ratio matches viewport
	      gl.glMatrixMode(GL10.GL_PROJECTION); // Select projection matrix
	      gl.glLoadIdentity();                 // Reset projection matrix
	      // Use perspective projection
	      GLU.gluPerspective(gl, 45, aspect, 0.1f, 100.f);
	  
	      gl.glMatrixMode(GL10.GL_MODELVIEW);  // Select model-view matrix
	      gl.glLoadIdentity();                 // Reset

	}
	@Override
	public void onDrawFrame(GL10 gl) {
		
//		Log.v("GREATCAT", "onDrawFrame");
	      // Clear color and depth buffers using clear-value set earlier
	      gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
	      
	      
	      gl.glLoadIdentity();                 // Reset model-view matrix ( NEW )
	      gl.glTranslatef(0.0f, 0.0f, -6.0f); // Translate left and into the screen ( NEW )
	      gl.glRotatef(angleTriangle, 0.0f, 1.0f, 0.0f); // Rotate the triangle about the y-axis (NEW)
	      triangle.draw(gl);                   // Draw triangle ( NEW )
	
   
	      angleTriangle += speedTriangle; // (NEW)
      
	}  

}



class Triangle {
	   FloatBuffer vertexBuffer;  // Buffer for vertex-array
	   ByteBuffer indexBuffer;    // Buffer for index-array
	   private FloatBuffer colorBuffer;   // Buffer for color-array
	  
	   float[] vertices = {  // Vertices of the triangle
	       0.0f,  1.0f, 0.0f, // 0. top
	      -1.0f, -1.0f, 0.0f, // 1. left-bottom
	       1.0f, -1.0f, 0.0f  // 2. right-bottom
	   };
	   byte[] indices = { 0, 1, 2 }; // Indices to above vertices (in CCW)
	   private float[] colors = { // Colors for the vertices (NEW)
			      1.0f, 0.0f, 0.0f, 1.0f, // Red (NEW)
			      0.0f, 1.0f, 0.0f, 1.0f, // Green (NEW)
			      0.0f, 0.0f, 1.0f, 1.0f  // Blue (NEW)
			   };	 
	   // Constructor - Setup the data-array buffers
	   Triangle() {
	      // Setup vertex-array buffer. Vertices in float. A float has 4 bytes.
	      ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
	      vbb.order(ByteOrder.nativeOrder()); // Use native byte order
	      vertexBuffer = vbb.asFloatBuffer(); // Convert byte buffer to float
	      vertexBuffer.put(vertices);         // Copy data into buffer
	      vertexBuffer.position(0);           // Rewind
	      
	      // Setup color-array buffer. Colors in float. A float has 4 bytes (NEW)
	      ByteBuffer cbb = ByteBuffer.allocateDirect(colors.length * 4);
	      cbb.order(ByteOrder.nativeOrder()); // Use native byte order (NEW)
	      colorBuffer = cbb.asFloatBuffer();  // Convert byte buffer to float (NEW)
	      colorBuffer.put(colors);            // Copy data into buffer (NEW)
	      colorBuffer.position(0);            // Rewind (NEW)    
	      
	      // Setup index-array buffer. Indices in byte.
	      indexBuffer = ByteBuffer.allocateDirect(indices.length);
	      indexBuffer.put(indices);
	      indexBuffer.position(0);
	   }
	  
	   // Render this shape
	   void draw(GL10 gl) {
	      // Enable vertex-array and define the buffers
	      gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
	      gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
	      gl.glEnableClientState(GL10.GL_COLOR_ARRAY);          // Enable color-array (NEW)
	      gl.glColorPointer(4, GL10.GL_FLOAT, 0, colorBuffer);  // Define color-array buffer (NEW)
	      
	      
	      // Draw the primitives via index-array
	      gl.glDrawElements(GL10.GL_TRIANGLES, indices.length, GL10.GL_UNSIGNED_BYTE, indexBuffer);
	      gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
	      gl.glDisableClientState(GL10.GL_COLOR_ARRAY);   // Disable color-array (NEW) 
	   }
}