package com.aoh.opengl;

import com.aoh.opengl.RenderScene;

import android.content.Context;

import android.opengl.GLSurfaceView;

import android.view.KeyEvent;

import android.view.MotionEvent;

public class ControlKey extends GLSurfaceView {

	public ControlKey(Context context) {

		super(context);

		renderScene = new RenderScene(context);

		setRenderer(renderScene);

		setFocusable(true);

		setFocusableInTouchMode(true);	//터치

		// TODO Auto-generated constructor stub

	}

	@Override

	public boolean onTouchEvent(MotionEvent event) {

		// TODO Auto-generated method stub

		float x = 0;

		float y = 0;		

		if(event.getAction() == MotionEvent.ACTION_DOWN) {

            x = event.getX();

            y = event.getY();

        }

        if (event.getAction() == MotionEvent.ACTION_MOVE) {

            final float xdif = (x - event.getX());

            final float ydif = (y - event.getY());

            queueEvent(new Runnable() {

                public void run() {

                 RenderScene.setXAngle(RenderScene.getXAngle() + ydif);

                 RenderScene.setYAngle(RenderScene.getYAngle() + xdif);

                }

            });

            x = event.getX();

            y = event.getY();

        }

        return true;

	}

	@Override

	public boolean onKeyDown(int keyCode, KeyEvent event) {

		// TODO Auto-generated method stub

		switch(keyCode){

		case KeyEvent.KEYCODE_DPAD_UP:

			renderScene.up();

			requestRender();

			return true;

		case KeyEvent.KEYCODE_DPAD_DOWN:

			renderScene.down();

			requestRender();

			return true;

		case KeyEvent.KEYCODE_DPAD_LEFT:

			renderScene.left();

			requestRender();

			return true;

		case KeyEvent.KEYCODE_DPAD_RIGHT:

			renderScene.right();

			requestRender();

			return true;	

		case KeyEvent.KEYCODE_Z:

			renderScene.zoom_in();

			requestRender();

			return true;

		case KeyEvent.KEYCODE_X:

			renderScene.zoom_out();

			requestRender();

			return true;

		}

		return super.onKeyDown(keyCode, event);

	}

	private RenderScene renderScene;

}

 package com.aoh.menu;

import com.aoh.opengl.ControlKey;

import android.app.Activity;

import android.os.Bundle;

public class AOHActivity extends Activity {

    /** Called when the activity is first created. */

    @Override

    public void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        controlKey = new ControlKey(this);

        setContentView(controlKey);

    }

    private ControlKey controlKey;

}

 package com.aoh.opengl;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.opengl.GLU;

import android.opengl.GLSurfaceView.Renderer;

import com.aoh.opengl.Render;

public class RenderScene implements Renderer{

	private Context c;

	private Render t = new Render(c);

	private static float xangle = 0.0f;

	private static float yangle = 0.0f;

	private static float x_move = 0.0f;

	private static float y_move = 0.0f;

	private static float z_move = 10.0f;

	public float[] pos= {10.0f, 10.0f, 10.0f, 1.0f};

	public float[] amb = {1.0f, 1.0f, 1.0f, 1.0f};

	public float[] dif = {0.5f, 0.5f, 0.5f, 1.0f};

	public float[] spe = {0.8f, 0.8f, 0.8f, 1.0f};

	public RenderScene(Context context) {

		// TODO Auto-generated constructor stub

		c = context;

	}

	@Override

	public void onDrawFrame(GL10 gl) {

		// TODO Auto-generated method stub

		gl.glClear(GL10.GL_COLOR_BUFFER_BIT|GL10.GL_DEPTH_BUFFER_BIT);

		//gl.glPushMatrix();

		gl.glEnable(GL10.GL_DEPTH_TEST);

		gl.glShadeModel(GL10.GL_SMOOTH);

		//gl.glColor4f(0, 0, 1, 1);

		gl.glLoadIdentity();

		GLU.gluLookAt(gl, 0.0f, 0.0f, z_move, x_move, y_move, 0.0f, 0.0f, 1.0f, 0.0f);

	//	gl.glTranslatef(0.0f, 0.0f, 0.0f);

		gl.glRotatef(xangle , 1, 0, 0);

		gl.glRotatef(yangle, 0, 1, 0);

		gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

		gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

		t.draw(gl);

		//gl.glPopMatrix();

		gl.glFlush();

	}

	@Override

	public void onSurfaceChanged(GL10 gl, int width, int height) {

		// TODO Auto-generated method stub

		float aspect = (float)width/height;

		gl.glViewport(0, 0, width, height);

		gl.glMatrixMode(GL10.GL_PROJECTION);

		gl.glLoadIdentity();

		GLU.gluPerspective(gl, 45.0f, aspect, 1, 1000000);

		gl.glMatrixMode(GL10.GL_MODELVIEW);

		gl.glLoadIdentity();

	}

	@Override

	public void onSurfaceCreated(GL10 gl, EGLConfig config) {

		// TODO Auto-generated method stub

		gl.glClear(GL10.GL_COLOR_BUFFER_BIT|GL10.GL_DEPTH_BUFFER_BIT);

		gl.glClearColor(0, 0, 0, 1);

		gl.glEnable(GL10.GL_LIGHTING);

		gl.glEnable(GL10.GL_LIGHT0);		 

		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, pos, 0);

		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, amb, 0);

		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, dif, 0);

		gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_SPECULAR, spe, 0);

		gl.glEnable(GL10.GL_LIGHT0);

		gl.glMatrixMode(GL10.GL_MODELVIEW);

		//gl.glEnable(GL10.GL_TEXTURE_2D);

		//int[] textures = new int[1];

		//gl.glGenTextures(1, textures, 0);

		//gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);

		//gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_NEAREST);

		//gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

		//Bitmap bitmap = BitmapFactory.decodeResource(c.getResources(), R.drawable.test);

		//Bitmap bitmap256 = Bitmap.createScaledBitmap(bitmap, 256, 256, false);

		//GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap256, 0);

		//bitmap.recycle();

		//bitmap256.recycle();

	}

	public void up(){

		y_move--;

	}

	public void down(){

		y_move++;

	}

	public void right(){

		x_move--;

	}

	public void left(){

		x_move++;

	}

	public void zoom_in(){

		z_move--;

	}

	public void zoom_out(){

		z_move++;

	}

	public static float getYAngle() {

		// TODO Auto-generated method stub

		return yangle;

	}

	public static float getXAngle() {

		// TODO Auto-generated method stub

		return xangle;

	}

	public static void setXAngle(float f) {

		// TODO Auto-generated method stub

		//f=0.0f;

		xangle = f/4.0f;

	}

	public static void setYAngle(float f) {

		// TODO Auto-generated method stub

		//f=0.0f;

		yangle = f/4.0f;

		}

}

 package com.aoh.opengl;

import java.io.BufferedReader;

import java.io.IOException;

import java.io.InputStream;

import java.io.InputStreamReader;

import java.nio.FloatBuffer;

import java.util.StringTokenizer;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.content.res.AssetManager;

import android.util.Log;

import com.aoh.opengl.Object;

public class Render extends BufferGLUT{

	public Render(Context context){

		try {

			AssetManager am = c.getAssets();

			InputStream is =c.getAssets().open("test.ASE");

			load("test.ASE");

		} catch (IOException e) {

			// TODO Auto-generated catch block

			e.printStackTrace();

		}

		Log.e("aho","before");

		mVertexBuffer = getFloatBufferFromFloatArray(vertices);

		Log.e("ahoo", "after");

//		mIndexBuffer = getShortBufferFromShortArray(index);

//		mTextureBuffer = getFloatBufferFromFloatArray(texCoords);

		c = context;

	}

/*	float []texCoords ={

			0,1, 1,1, 0,0,

			1,1, 1,0, 0,0,

	};*/

	float []vertices;

	public void load(String fileName){

		try{			

			//List<String> lines = null;

			BufferedReader br = new BufferedReader(new InputStreamReader(this.c.getAssets().open(fileName)));

			String line = null;

			String waste = null;

			int waste1 = 0;

			StringTokenizer tk = new StringTokenizer(line);

			while(line != "*MESH_NUMVERTEX"){

				line = br.readLine();			

			}

			object.NumVertex=Integer.valueOf(line);	

			line = br.readLine();

			object.NumFace=Integer.valueOf(line);

			object.vertex = new Vertex[object.NumVertex];

			object.face = new Face[object.NumFace];

			vertices = new float[object.NumVertex*3];

			int vertCounter = 0;

			br.readLine();		

			for(int loop = 0; loop < object.NumVertex; loop++){

				br.readLine();

				tk = new StringTokenizer(line);

				waste = String.valueOf(tk.nextToken());

				waste1 = Integer.valueOf(tk.nextToken());

				object.vertex[loop].x = Float.valueOf(tk.nextToken());

				object.vertex[loop].z = Float.valueOf(tk.nextToken());

				object.vertex[loop].y = Float.valueOf(tk.nextToken());

				vertices[vertCounter++] = object.vertex[loop].x;

				vertices[vertCounter++] = object.vertex[loop].y;

				vertices[vertCounter++] = object.vertex[loop].z;

				Log.e("x", ""+object.vertex[loop].x);

			}

			br.readLine();

			br.readLine();

			for(int loop = 0; loop < object.NumFace; loop++){

				br.readLine();

				tk = new StringTokenizer(line);

				waste = String.valueOf(tk.nextToken());

				waste = String.valueOf(tk.nextToken());

				waste = String.valueOf(tk.nextToken());

				object.face[loop].First = Integer.valueOf(tk.nextToken());

				waste = String.valueOf(tk.nextToken());

				object.face[loop].Second = Integer.valueOf(tk.nextToken());

				waste = String.valueOf(tk.nextToken());

				object.face[loop].Third = Integer.valueOf(tk.nextToken());

			}

			//br.close();

		}

		catch(Exception e){

		}

	}

	void draw(GL10 gl){

		gl.glFrontFace(GL10.GL_CW);

//		gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, mTextureBuffer);

		gl.glVertexPointer(3, GL10.GL_FLOAT, 0, mVertexBuffer);

	//	gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

		//gl.glDrawElements(GL10.GL_TRIANGLES, index.length, GL10.GL_UNSIGNED_SHORT, mIndexBuffer);

		//gl.glEnable(GL10.GL_TEXTURE_2D);

		//main Bottom

		for(int i=0;i<object.NumFace;i++){

		//	gl.glNormal3f(0.0f, 0.0f, 1.0f);

			gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);

			if(i%3==0)

			gl.glDrawArrays(GL10.GL_TRIANGLES, i, 3);

		}

	//		gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

	}

	private Object object;

	private Context c;

	private FloatBuffer mVertexBuffer;

//	private FloatBuffer mTextureBuffer;

//	private ShortBuffer mIndexBuffer;

}