openGL在surfaceview中实例

package com.macrocheng.cubeopengl;

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

import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGL11;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import javax.microedition.khronos.opengles.GL10;

import android.app.Activity;
import android.content.Context;
import android.graphics.Bitmap;
import android.opengl.GLU;
import android.util.Log;
import android.view.SurfaceHolder;
import android.view.SurfaceView;

public abstract class GLTutorialBase extends SurfaceView implements SurfaceHolder.Callback, Runnable {
 protected EGLContext glContext;
 protected ViewAnimator animator;
 protected SurfaceHolder sHolder;
 protected Thread t;
 protected boolean running;
 int width;
 int height;
 boolean resize;
 int fps;

 /**
  * Make a direct NIO FloatBuffer from an array of floats
  * @param arr The array
  * @return The newly created FloatBuffer
  */
 protected static FloatBuffer makeFloatBuffer(float[] arr) {
  //分配新的直接字节缓冲区
  ByteBuffer bb = ByteBuffer.allocateDirect(arr.length*4);
     //将获取的底层平台的本机字节顺序设置到新的缓冲区
  bb.order(ByteOrder.nativeOrder());
  //作为 float 缓冲区
  FloatBuffer fb = bb.asFloatBuffer();
  fb.put(arr);
  fb.position(0);
  return fb;
 }

 /**
  * Make a direct NIO IntBuffer from an array of ints
  * @param arr The array
  * @return The newly created IntBuffer
  */
 protected static IntBuffer makeFloatBuffer(int[] arr) {
  ByteBuffer bb = ByteBuffer.allocateDirect(arr.length*4);
  bb.order(ByteOrder.nativeOrder());
  IntBuffer ib = bb.asIntBuffer();
  ib.put(arr);
  ib.position(0);
  return ib;
 }

 /**
  * Create a texture and send it to the graphics system
  * @param gl The GL object
  * @param bmp The bitmap of the texture
  * @param reverseRGB Should the RGB values be reversed?  (necessary workaround for loading .pngs...)
  * @return The newly created identifier for the texture.
  */
 protected static int loadTexture(GL10 gl, Bitmap bmp) {
  return loadTexture(gl, bmp, false);
 }

 /**
  * Create a texture and send it to the graphics system
  * @param gl The GL object
  * @param bmp The bitmap of the texture
  * @param reverseRGB Should the RGB values be reversed?  (necessary workaround for loading .pngs...)
  * @return The newly created identifier for the texture.
  */
 protected static int loadTexture(GL10 gl, Bitmap bmp, boolean reverseRGB) {
  ByteBuffer bb = ByteBuffer.allocateDirect(bmp.getHeight()*bmp.getWidth()*4);
  bb.order(ByteOrder.BIG_ENDIAN);
  IntBuffer ib = bb.asIntBuffer();

  for (int y=bmp.getHeight()-1;y>-1;y--)
   for (int x=0;x<bmp.getWidth();x++) {
    int pix = bmp.getPixel(x,bmp.getHeight()-y-1);
    // Convert ARGB -> RGBA
    @SuppressWarnings("unused")
    byte alpha = (byte)((pix >> 24)&0xFF);
    byte red = (byte)((pix >> 16)&0xFF);
    byte green = (byte)((pix >> 8)&0xFF);
    byte blue = (byte)((pix)&0xFF);

    // It seems like alpha is currently broken in Android...
    ib.put(red << 24 | green << 16 | blue << 8 | 0xFF);//255-alpha);
   }
  ib.position(0);
  bb.position(0);

  int[] tmp_tex = new int[1];

  gl.glGenTextures(1, tmp_tex, 0);
  int tex = tmp_tex[0];
  gl.glBindTexture(GL10.GL_TEXTURE_2D, tex);
  gl.glTexImage2D(GL10.GL_TEXTURE_2D, 0, GL10.GL_RGBA, bmp.getWidth(), bmp.getHeight(), 0, GL10.GL_RGBA, GL10.GL_UNSIGNED_BYTE, bb);
  gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
  gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

  return tex;
 }

 /**
  * Constructor
  * @param c The View's context.
  */
 public GLTutorialBase(Context c) {
  this(c, -1);
 }

 /**
  * Constructor for animated views
  * @param c The View's context
  * @param fps The frames per second for the animation.
  */
 public GLTutorialBase(Context c, int fps) {
  super(c);
  Log.i("GLTutorialBase", "GLTutorialBase");
  sHolder = getHolder();
  sHolder.addCallback(this);
  sHolder.setType(SurfaceHolder.SURFACE_TYPE_GPU);
  this.fps = fps;
 }

 @Override
 protected void onAttachedToWindow() {
  if (animator != null) {
   // If we're animated, start the animation
   animator.start();
  }
  super.onAttachedToWindow();
 }

 @Override
 protected void onDetachedFromWindow() {
  if (animator != null) {
   // If we're animated, stop the animation
   animator.stop();
  }
  super.onDetachedFromWindow();
 }

 public void surfaceChanged(SurfaceHolder holder, int format, int width,
   int height) {
  synchronized (this) {
   this.width = width;
   this.height = height;
   this.resize = true;
  }
 }

 public void surfaceCreated(SurfaceHolder holder) {
  t = new Thread(this);
  t.start();
 }

 public void surfaceDestroyed(SurfaceHolder arg0) {
  running = false;
  try {
   t.join();
  }
  catch (InterruptedException ex) {}
  t = null;
 }

 public void run() {
  // Much of this code is from GLSurfaceView in the Google API Demos.
  // I encourage those interested to look there for documentation.
  //创建一个EGL实例
  EGL10 egl = (EGL10)EGLContext.getEGL();
  //
  EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
  //初始化EGLDisplay
  int[] version = new int[2];
        egl.eglInitialize(dpy, version);

        int[] configSpec = {
                EGL10.EGL_RED_SIZE,      5,
                EGL10.EGL_GREEN_SIZE,    6,
                EGL10.EGL_BLUE_SIZE,     5,
                EGL10.EGL_DEPTH_SIZE,   16,
                EGL10.EGL_NONE
        };

        EGLConfig[] configs = new EGLConfig[1];
        int[] num_config = new int[1];
        //选择config创建opengl运行环境
        egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config);
        EGLConfig config = configs[0];

  EGLContext context = egl.eglCreateContext(dpy, config,
                EGL10.EGL_NO_CONTEXT, null);
        //创建新的surface
  EGLSurface surface = egl.eglCreateWindowSurface(dpy, config, sHolder, null);
  //将opengles环境设置为当前
  egl.eglMakeCurrent(dpy, surface, surface, context);
        //获取当前opengles画布
  GL10 gl = (GL10)context.getGL();

  init(gl);

  int delta = -1;
  if (fps > 0) {
   delta = 1000/fps;
  }
  long time = System.currentTimeMillis();

  running = true;
  while (running) {
   int w, h;
   synchronized(this) {
    w = width;
    h = height;
   }
   if (System.currentTimeMillis()-time < delta) {
    try {
     Thread.sleep(System.currentTimeMillis()-time);
    }
    catch (InterruptedException ex) {}
   }
   drawFrame(gl, w, h);
   //显示绘制结果到屏幕上
   egl.eglSwapBuffers(dpy, surface);

            if (egl.eglGetError() == EGL11.EGL_CONTEXT_LOST) {
                Context c = getContext();
                if (c instanceof Activity) {
                    ((Activity)c).finish();
                }
            }
            time = System.currentTimeMillis();
  }
        egl.eglMakeCurrent(dpy, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
        egl.eglDestroySurface(dpy, surface);
        egl.eglDestroyContext(dpy, context);
        egl.eglTerminate(dpy);
 }

 private void drawFrame(GL10 gl, int w, int h) {
  if (resize) {
   resize(gl, w, h);
   resize = false;
  }
  drawFrame(gl);
 }

 protected void resize(GL10 gl, int w, int h) {
  gl.glMatrixMode(GL10.GL_PROJECTION);//GL_PROJECTION,对投影矩阵应用随后的矩阵操作.
  gl.glLoadIdentity();//重置当前指定的矩阵为单位矩阵
  gl.glViewport(0,0,w,h);
  GLU.gluPerspective(gl, 45.0f, ((float)w)/h, 1f, 100f);
 }

 protected void init(GL10 gl) {}

 protected abstract void drawFrame(GL10 gl);
}

package com.macrocheng.cubeopengl;

import java.nio.FloatBuffer;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.opengl.GLU;
import android.opengl.GLUtils;
import android.util.Log;
import android.view.MotionEvent;

/**
 * http://www.zeuscmd.com/tutorials/opengles/20-Transparency.php
 * @author bburns
 *
 */
public class GLTutorialCube extends GLTutorialBase  {
    float lightAmbient[] = new float[] { 0.6f, 0.6f, 0.6f, 1.0f };
 float lightDiffuse[] = new float[] { 0.6f, 0.6f, 0.6f, 1.0f };
 float[] lightPos = new float[] {0,0,3,1};

 float matAmbient[] = new float[] { 1f, 1f, 1f, 1.0f };
 float matDiffuse[] = new float[] { 1f, 1f, 1f, 1.0f };

 int tex;
 Bitmap[] bmp = new Bitmap[6];
 int[] tmp_tex = new int[6];

 float box[][] = new float[][] {
         {
   -0.5f, -0.5f,  0.5f,
    0.5f, -0.5f,  0.5f,
   -0.5f,  0.5f,  0.5f,
    0.5f,  0.5f,  0.5f,
         },

         {
   -0.5f, -0.5f, -0.5f,
   -0.5f,  0.5f, -0.5f,
    0.5f, -0.5f, -0.5f,
    0.5f,  0.5f, -0.5f,
         },

         {
   -0.5f, -0.5f,  0.5f,
   -0.5f,  0.5f,  0.5f,
   -0.5f, -0.5f, -0.5f,
   -0.5f,  0.5f, -0.5f,
         },

         {
    0.5f, -0.5f, -0.5f,
    0.5f,  0.5f, -0.5f,
    0.5f, -0.5f,  0.5f,
    0.5f,  0.5f,  0.5f,
         },

         {
   -0.5f,  0.5f,  0.5f,
    0.5f,  0.5f,  0.5f,
    -0.5f,  0.5f, -0.5f,
    0.5f,  0.5f, -0.5f,
         },

         {
   -0.5f, -0.5f,  0.5f,
   -0.5f, -0.5f, -0.5f,
    0.5f, -0.5f,  0.5f,
    0.5f, -0.5f, -0.5f,
         },
  };

 float texCoords[][] = new float[][] {
         {
    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,
         },

         {
    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f,
         },

         {
    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f,
         },

         {
    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f,
         },

         {
    0.0f, 0.0f,
    1.0f, 0.0f,
    0.0f, 1.0f,
    1.0f, 1.0f,
         },

         {
   // BOTTOM
    1.0f, 0.0f,
    1.0f, 1.0f,
    0.0f, 0.0f,
    0.0f, 1.0f,
         }
  };

 FloatBuffer[] cubeBuff = new FloatBuffer[6];
 FloatBuffer[] texBuff = new FloatBuffer[6];

 public GLTutorialCube(Context c) {
  super(c, 20);

  for(int i = 0;i<box.length;i++)
  {
      cubeBuff[i] = makeFloatBuffer(box[i]);
      texBuff[i] = makeFloatBuffer(texCoords[i]);
  }

  bmp[0] = BitmapFactory.decodeResource(c.getResources(), R.drawable.aa);
  bmp[1] = BitmapFactory.decodeResource(c.getResources(), R.drawable.bb);
  bmp[2] = BitmapFactory.decodeResource(c.getResources(), R.drawable.cc);
  bmp[3] = BitmapFactory.decodeResource(c.getResources(), R.drawable.dd);
  bmp[4] = BitmapFactory.decodeResource(c.getResources(), R.drawable.ee);
  bmp[5] = BitmapFactory.decodeResource(c.getResources(), R.drawable.ff);
        Log.i("GLTutorialCube", "GLTutorialCube");
  setFocusable(true);
  Log.i("GLTutorialCube", "GLTutorialCube");
  
 }

 protected void init(GL10 gl) {
  Log.i("GLTutorialCube", "init");
  gl.glEnable(GL10.GL_LIGHTING);
  gl.glEnable(GL10.GL_LIGHT0);
  gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_AMBIENT, matAmbient, 0);
  gl.glMaterialfv(GL10.GL_FRONT_AND_BACK, GL10.GL_DIFFUSE, matDiffuse, 0);

  gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_AMBIENT, lightAmbient, 0);
  gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_DIFFUSE, lightDiffuse, 0);
  gl.glLightfv(GL10.GL_LIGHT0, GL10.GL_POSITION, lightPos, 0);

  gl.glEnable(GL10.GL_BLEND);
  gl.glDisable(GL10.GL_DEPTH_TEST);
//  gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE);

  gl.glEnable(GL10.GL_TEXTURE_2D);

  gl.glShadeModel(GL10.GL_SMOOTH);
  gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
  gl.glClearDepthf(1.0f);

  gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
        gl.glMatrixMode(GL10.GL_MODELVIEW);
        gl.glLoadIdentity();
        gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
        gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
        gl.glEnable(GL10.GL_TEXTURE_2D);
        gl.glShadeModel(GL10.GL_SMOOTH);
        gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
        gl.glClearDepthf(1.0f);
        gl.glEnable(GL10.GL_DEPTH_TEST);
        gl.glDepthFunc(GL10.GL_LEQUAL);
        gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);

  gl.glGenTextures(6, tmp_tex, 0);
        gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);
        for(int i = 0; i < 6; i++)
        {
            gl.glBindTexture(GL10.GL_TEXTURE_2D, tmp_tex[i]);
            GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bmp[i], 0);
        }
 }

 float xrot = 45.0f;
 float yrot = 45.0f;

 protected void drawFrame(GL10 gl) {
  Log.i("GLTutorialCube", "drawFrame");
  gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

  gl.glMatrixMode(GL10.GL_MODELVIEW);
  gl.glLoadIdentity();
  GLU.gluLookAt(gl, 0, 0, 3, 0, 0, 0, 0, 1, 0);

  gl.glRotatef(xrot, 1, 0, 0);
  gl.glRotatef(yrot, 0, 1, 0);

   for(int i = 0; i < 6; i++)
         {
             gl.glBindTexture(GL10.GL_TEXTURE_2D, tmp_tex[i]);
             gl.glVertexPointer(3, GL10.GL_FLOAT, 0, cubeBuff[i]);
             gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texBuff[i]);
             gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);
         }

   if(flag == 1)
        {
            xrot += 2.0f;

        }else if(flag == 2)
        {
            xrot -= 2.0f;
        }else if(flag == 3)
        {
            yrot += 2.0f;
        }else if(flag == 4)
        {
            yrot -= 2.0f;
        }

        if(flag == 1 || flag == 2)
        if((int)(xrot%90)==0)
        {
            flag = 0;
        }
        if(flag == 3 || flag == 4)
        if((int)(yrot%90) ==0)
        {
            flag =0;
        }
 }

 float _x;
    float _y;
    int flag;
    public boolean onTouchEvent(final MotionEvent event) {
     Log.i("GLTutorialCube", "onTouchEvent");
        if (event.getAction() == MotionEvent.ACTION_DOWN) {
            _x = event.getX();
            _y = event.getY();
        }
        if(event.getAction() == MotionEvent.ACTION_MOVE)
        {
            yrot += (_x - event.getX())/10;
            xrot += (_y - event.getY())/10;
        }
        return true;
    }

}