zhangge's stupid and messy life

//生成纹理ID
int[] textures = new int[1];

//第一个参数是生成纹理的数量，最后一个参数是偏移量
GLES20.glGenTextures(1, textures, 0);

uniform mat4 uMVPMatrix; //总变换矩阵
attribute vec3 aPosition;  //顶点位置
attribute vec2 aTexCoor;    //纹理坐标
varying vec2 vTextureCoord;  //用于传递给片元着色器的变量
void main()     
{                            		
   gl_Position = uMVPMatrix * vec4(aPosition,1); //根据总变换矩阵计算此次绘制此顶点位置
   vTextureCoord = aTexCoor;//将接收的纹理坐标传递给片元着色器
}

precision mediump float;//告诉精度是float
varying vec2 vTextureCoord; //接收的纹理坐标
uniform sampler2D sTexture;//纹理内容数据
void main()                         
{           
   //给此片元从纹理中采样出颜色值            
   gl_FragColor = texture2D(sTexture, vTextureCoord); 
}

public class ZGDanmakuView extends GLSurfaceView {
    private Context mContext;
    public ZGDanmakuView(Context context) {
        super(context);
        init(context);
    }
    public ZGDanmakuView(Context context, AttributeSet attrs) {
        super(context, attrs);
        init(context);
    }
    private void init(Context context) {
        this.mContext = context;

        //设置使用opengles 2.0
        setEGLContextClientVersion(2);

        //设置EGL的像素配置
        setEGLConfigChooser(8, 8, 8, 8, 16, 0);

        ZGDanmakuRenderer renderer = new ZGDanmakuRenderer();
        setRenderer(renderer);

        //设置view为透明，并置于顶层，可以在surfaceview之上
        getHolder().setFormat(PixelFormat.TRANSLUCENT);
        setZOrderOnTop(true);

        //设置渲染模式为主动渲染，即有一条后台OPENGL线程每帧都调用onDrawFrame方法
        setRenderMode(GLSurfaceView.RENDERMODE_CONTINUOUSLY);
    }
}

public class ZGDanmakuRenderer implements GLSurfaceView.Renderer {
	//...省略不必要的代码了
    @Override
    public void onSurfaceChanged(GL10 gl10, int width, int height) {
        this.mViewWidth = width;
        this.mViewHeight = height;

        //设置视窗大小及位置为整个view范围
        GLES20.glViewport(0, 0, width, height);

        //计算产生正交投影矩阵
        //一般会设置前两个参数为-width / height，width / height，使得纹理不会变形，
        //但是我这里不这样设置，为了控制位置，变形这个问题在顶点坐标那里处理即可
        MatrixUtils.setProjectOrtho(-1, 1, -1, 1, 0, 1);

        //产生摄像机9参数位置矩阵
        MatrixUtils.setCamera(0, 0, 1, 0f, 0f, 0f, 0f, 1, 0);

        mLastTime = SystemClock.elapsedRealtime();
    }

    @Override
    public void onDrawFrame(GL10 gl10) {
        long currentTime = SystemClock.elapsedRealtime();
        float intervalTime = (float)(currentTime - mLastTime) / 1000.0f;
        float detalOffset = mSpeed * intervalTime;

        //设置屏幕背景色RGBA
        GLES20.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);

        //清除深度缓冲与颜色缓冲
        GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        //绘制弹幕纹理
        List<ZGDanmaku> danmakus = mDanmakus;
        int size = danmakus.size();
        for (int i = 0; i < size; i ++) {
            ZGDanmaku danmaku = danmakus.get(i);
            float newOffset = detalOffset + danmaku.getCurrentOffsetX();
            danmaku.setOffsetX(newOffset);
            danmaku.drawDanmaku();
        }
        mLastTime = currentTime;
    }
}

public void initVertexData() {
    //顶点坐标数据
    //首先归一化计算弹幕在坐标系中的宽高
    float danmakuHeight = (float) mBitmap.getHeight() / mViewHeight * 2.0f;
    float danmakuWidth = (float) mBitmap.getWidth() / mViewWidth * 2.0f;

    //弹幕四个角的顶点坐标，我默认把它绘制在屏幕的左上角了，这样方便理解偏移计算
    //为什么不是顺时针或者逆时针，实际上opengl只能绘制三角形，所以，
    //这里其实是绘制了两个三角形的，前三个点和后三个点分别是三角形
    float vertices[] = new float[]
            {
                    -1, 1, 0,                                   //左上角
                    -(1 - danmakuWidth), 1, 0,                  //右上角
                    -1, 1 - danmakuHeight, 0,                   //左下角
                    -(1 - danmakuWidth), 1 - danmakuHeight, 0   //右下角
            };

    //一个float是4个字节，所以*4
    //关于ByteBuffer，可以看nio相关知识：http://zhgeaits.me/java/2013/06/17/Java-nio.html
    ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
    vbb.order(ByteOrder.nativeOrder());
    mVertexBuffer = vbb.asFloatBuffer();
    mVertexBuffer.put(vertices);
    mVertexBuffer.position(0);

    //纹理坐标，同理是两个三角形的图元。
    float texCoor[] = new float[]
            {
                    0, 0,   //左上角
                    1, 0,   //右上角
                    0, 1,   //左下角
                    1, 1    //右下角
            };

    ByteBuffer cbb = ByteBuffer.allocateDirect(texCoor.length * 4);
    cbb.order(ByteOrder.nativeOrder());
    mTexCoorBuffer = cbb.asFloatBuffer();
    mTexCoorBuffer.put(texCoor);
    mTexCoorBuffer.position(0);
}

muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");
maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");
maTexCoorHandle = GLES20.glGetAttribLocation(mProgram, "aTexCoor");

//绑定纹理，并指定纹理的采样方式
GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureId);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER, GLES20.GL_NEAREST);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MAG_FILTER, GLES20.GL_LINEAR);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S, GLES20.GL_CLAMP_TO_EDGE);
GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T, GLES20.GL_CLAMP_TO_EDGE);

//纹理类型在OpenGL ES中必须为GL10.GL_TEXTURE_2D
//第二个参数是纹理的层次，0表示基本图像层，可以理解为直接贴图
//最后一个参数是纹理边框尺寸
GLUtils.texImage2D(GLES20.GL_TEXTURE_2D, 0, mBitmap, 0);

mBitmap.recycle();

public void drawDanmaku() {
    //使用3.3.2创建的shader程序ID
    GLES20.glUseProgram(mProgram);

    //初始化矩阵
    MatrixUtils.setInitStack();

    //首先把弹幕移动到右上角，由3.3.1可以理解这里
    MatrixUtils.transtate(2.0f, 0, 0);

    //弹幕平移，同理坐标放大两倍
    float unitY = -offsetY / mViewHeight * 2.0f;
    float unitX = -offsetX / mViewWidth * 2.0f;
    MatrixUtils.transtate(unitX, unitY, 0);

    //将最终变换矩阵传入shader程序
    GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, MatrixUtils.getFinalMatrix(), 0);

    //传递顶点位置数据
    //坐标是xyz三维，所以size是3，每个float是4个字节，所以stride是3 * 4
    GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 3 * 4, mVertexBuffer);

    //传递纹理坐标数据
    //坐标是xy二维的，所以size是2
    GLES20.glVertexAttribPointer(maTexCoorHandle, 2, GLES20.GL_FLOAT, false, 2 * 4, mTexCoorBuffer);

    //允许使用坐标数据数组
    GLES20.glEnableVertexAttribArray(maPositionHandle);
    GLES20.glEnableVertexAttribArray(maTexCoorHandle);

    //绑定纹理
    GLES20.glActiveTexture(GLES20.GL_TEXTURE0);
    GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureId);

    //绘制纹理矩形
    GLES20.glDrawArrays(GLES20.GL_TRIANGLE_STRIP, 0, mVertexCount);
}