Android 真正的3D Gallery

主要实现的类：

package com.ws.wsvod.opengl;

import java.io.File;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;
import java.nio.IntBuffer;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import com.ws.wsvod.converflow.BitmapCanvas;
import com.ws.wsvod.converflow.DataCache;

import android.content.Context;
import android.graphics.Bitmap;
import android.graphics.BitmapFactory;
import android.graphics.Canvas;
import android.graphics.Paint;
import android.graphics.PixelFormat;
import android.graphics.Rect;
import android.graphics.RectF;
import android.opengl.GLSurfaceView;
import android.opengl.GLU;
import android.opengl.GLUtils;
import android.util.Log;
import android.view.MotionEvent;
import android.view.VelocityTracker;
import android.view.animation.AnimationUtils;

public class CoverFlowOpenGL extends GLSurfaceView
        implements GLSurfaceView.Renderer {
    private static final String TAG = "AnotherCoverFlow";
    private static final int TOUCH_MINIMUM_MOVE = 5;
    private static final int IMAGE_SIZE = 128; // the bitmap size we use for the texture
    private static final int MAX_TILES = 48; // the maximum tiles in the cache
    private static final int VISIBLE_TILES = 3; // the visble tiles left and right

    private static final float SCALE = 0.5f; // the scale of surface view
    private static final float SPREAD_IMAGE = 0.24f;
    private static final float FLANK_SPREAD = 0.20f;
    private static final float FRICTION = 10.0f;
    private static final float MAX_SPEED = 6.0f;

    private static final float[] GVertices = new float[]{
            -1.0f, -1.0f, 0.0f,
            1.0f, -1.0f, 0.0f,
            -1.0f, 1.0f, 0.0f,
            1.0f, 1.0f, 0.0f,
    };

    private static final float[] GTextures = new float[]{
            0.0f, 1.0f,
            1.0f, 1.0f,
            0.0f, 0.0f,
            1.0f, 0.0f,
    };

    private GL10 mGLContext;
    private FloatBuffer mVerticesBuffer;
    private FloatBuffer mTexturesBuffer;
    private float[] mMatrix;

    private int mBgTexture;
    private FloatBuffer mBgVerticesBuffer;
    private FloatBuffer mBgTexturesBuffer;
    private int mBgBitmapId;
    private boolean mInitBackground;

    private float mOffset;
    private int mLastOffset;
    private RectF mTouchRect;

    private int mWidth;
    private int mHeight;
    private boolean mTouchMoved;
    private float mTouchStartPos;
    private float mTouchStartX;
    private float mTouchStartY;

    private float mStartOffset;
    private long mStartTime;

    private float mStartSpeed;
    private float mDuration;
    private Runnable mAnimationRunnable;
    private VelocityTracker mVelocity;

    private boolean mStopBackgroundThread;
    private CoverFlowListener mListener;
    private DataCache<Integer, CoverFlowRecord> mCache;

    public CoverFlowOpenGL(Context context) {
        super(context);

        setEGLConfigChooser(8, 8, 8, 8, 16, 0);

        setRenderer(this);
//        setRenderMode(RENDERMODE_WHEN_DIRTY);

        getHolder().setFormat(PixelFormat.TRANSLUCENT);
//        setZOrderMediaOverlay(true);
//        setZOrderOnTop(true);

        mCache = new DataCache<Integer, CoverFlowRecord>(MAX_TILES);
        mLastOffset = 0;
        mOffset = 0;
        mInitBackground = false;
        mBgBitmapId = 0;
    }

    public void setCoverFlowListener(CoverFlowListener listener) {
        mListener = listener;
    }

    private float checkValid(float off) {
        int max = mListener.getCount(this) - 1;
        if (off < 0)
            return 0;
        else if (off > max)
            return max;

        return off;
    }

    pub