Android OpenGL ES开发（六）立方体

之前讲过，OpenGL ES中绘制的两种方法：顶点法和索引法。这次绘制立方体使用索引法来绘制。
立方体是由六个正方形组成，我们将六个正方形绘制出来，立方体就绘制完毕。既然选择用索引法来绘制，立方体拥有八个顶点，我们先将这八个顶点列出来：

    private float cubeCoors[] = {
            -1.0f,1.0f,1.0f,    //正面左上0
            -1.0f,-1.0f,1.0f,   //正面左下1
            1.0f,-1.0f,1.0f,    //正面右下2
            1.0f,1.0f,1.0f,     //正面右上3
            -1.0f,1.0f,-1.0f,    //反面左上4
            -1.0f,-1.0f,-1.0f,   //反面左下5
            1.0f,-1.0f,-1.0f,    //反面右下6
            1.0f,1.0f,-1.0f     //反面右上7
    };

正面由032和021两个三角形组成，其他面诸如此类拆分，得索引数组：

    final short index[]={
            6,7,4,6,4,5,    //后面
            6,3,7,6,2,3,    //右面
            6,5,1,6,1,2,    //下面
            0,3,2,0,2,1,    //正面
            0,1,5,0,5,4,    //左面
            0,7,3,0,4,7,    //上面

    };

如果使用单一颜色，最后绘制出来的立方体不方便看效果，所以我们来绘制多种颜色的立方体出来。定义各个顶点颜色：

    private float color[] = {
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f
    };

顶点着色器

    private final String vertextShaderCode =
            "attribute vec4 vPosition;"+
            "uniform mat4 vMatrix;"+
            "attribute vec4 aColor;"+
            "varying  vec4 vColor;"+
            "void main() {"+
            "   gl_Position = vMatrix * vPosition;"+
            "   vColor = aColor;"+
            "}";

片元着色器

    private final String fragmentShaderCode =
            "precision mediump float;"+
            "varying vec4 vColor;"+
            "void main() {"+
            "   gl_FragColor = vColor;"+
            "}";

接着其他步骤与绘制三角形相同：

1、初始化坐标数据、索引数据、颜色数据，具体操作为将坐标数据、颜色数据分别写入到独自的FloatBuffer中，将索引数据写入到ShortBuffer中
2、创建OpenGL2.0程序，将顶点着色器和片元着色器加入到程序中，并链接程序。
3、使用创建的OpenGLES2.0程序，写入变换矩阵、顶点坐标数据及颜色数据。
4、索引法绘制出所有顶点坐标组成的三角形，得到一个立方体。

如果仅仅只做以上事情，往往得不到一个正确立方体，反而出现比较奇怪的立方体，比如这样：

1.jpg

这是因为没有开启深度测试GLES20.glEnable(GLES20.GL_DEPTH_TEST)，并在绘制前清除深度缓存导致的GLES20.glClear(GLES20.GL_DEPTH_BUFFER_BIT)。
加入之前，我们即可得到正常的立方体：

2.jpg

OpenGL里常出现深度测试，关于深度测试内容如下：

1、什么是深度？
深度其实就是该像素在3D世界中距离摄像机的距离（绘制坐标），深度缓存中存储这每个像素点（绘制在屏幕上的）的深度值！
深度值（Z值）越大，则离摄像机越远。
深度值是存储在深度缓存里面的，我们用深度缓存的位数来衡量深度缓存的精度。深度缓存位数越高，则精确度越高，目前的显卡一般都可支持16位的Z Buffer，一些高级的显卡已经支持32位的Z Buffer，单一般用24位Z Buffer就已经足够了。
2、为什么需要深度？
在不适用深度测试的时候，如果我们先绘制一个距离较近的物体，再绘制距离远的物体，则距离较远的物体因为后绘制，会把距离近的物体覆盖掉，这样的效果并不是我们所希望的，而有了深度缓冲以后，绘制物体的顺序就不那么重要了，都能按照远近正常显示，这很关键。
实际上，只要存在深度缓冲区，无论是否开启深度测试，OpenGL在像素被绘制时都会尝试将深度数据写入到缓冲区内，除非调用了glDepthMask(GL_FALSE)来禁止写入。这些深度数据除了用于常规的测试外，还可以用一些有趣的用途，比如绘制阴影等等。
3、启用深度测试
使用 glEnable(GL_DEPTH_TEST)；
在默认情况是将需要绘制的新像素的Z值与深度缓冲区中对应位置的Z值进行比较，如果比深度缓冲中的值小，那么用新像素的颜色值更新帧缓存中对应像素的颜色值。
但是可以使用glDepthFunc(func)来对这种默认测试方式进行修改。
其中参数func的值可以为GL_NEVER（没有处理）、GL_ALWAYS（处理所有）、GL_LESS（小于）、GL_LEQUAL（小于等于）、GL_EQUAL（等于）、GL_GEQUAL（大于等于）、GL_GREATER（大于）或GL_NOTEQUAL（不等于），其中默认值是GL_LESS。一般来将，使用glDepthFunc(GL_LEQUAL);来表达一般物体之间的遮挡关系。
4、启用深度测试，那么这就不适用于同时绘制不透明物体。

具体代码：

public class MyFifthRender implements GLSurfaceView.Renderer
{

    private final String vertextShaderCode =
            "attribute vec4 vPosition;"+
            "uniform mat4 vMatrix;"+
            "attribute vec4 aColor;"+
            "varying  vec4 vColor;"+
            "void main() {"+
            "   gl_Position = vMatrix * vPosition;"+
            "   vColor = aColor;"+
            "}";
    private final String fragmentShaderCode =
            "precision mediump float;"+
            "varying vec4 vColor;"+
            "void main() {"+
            "   gl_FragColor = vColor;"+
            "}";
    private float cubeCoors[] = {
            -1.0f,1.0f,1.0f,    //正面左上0
            -1.0f,-1.0f,1.0f,   //正面左下1
            1.0f,-1.0f,1.0f,    //正面右下2
            1.0f,1.0f,1.0f,     //正面右上3
            -1.0f,1.0f,-1.0f,    //反面左上4
            -1.0f,-1.0f,-1.0f,   //反面左下5
            1.0f,-1.0f,-1.0f,    //反面右下6
            1.0f,1.0f,-1.0f     //反面右上7
    };

    private float color[] = {
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        0f,1f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f,
        1f,0f,0f,1f
    };
    final short index[]={
            6,7,4,6,4,5,    //后面
            6,3,7,6,2,3,    //右面
            6,5,1,6,1,2,    //下面
            0,3,2,0,2,1,    //正面
            0,1,5,0,5,4,    //左面
            0,7,3,0,4,7,    //上面

    };
    private int program;
    private FloatBuffer vertexBuffer;
    //投影矩阵
    private final float[] mProjectMatrix = new float[16];
    //相机位置矩阵
    private final float[] mViewMatrix = new float[16];
    //计算变换矩阵
    private final float[] mMVPMatrix = new float[16];
    private FloatBuffer colorFloatBuffer;
    private ShortBuffer indexShortBuffer;

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config)
    {
        //将背景设置为灰色
        GLES20.glClearColor(0.0f,0.0f,0.0f,1.0f);
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT| GLES20.GL_DEPTH_BUFFER_BIT);
        //开启深度测试
        GLES20.glEnable(GLES20.GL_DEPTH_TEST);
        //申请底层空间
        ByteBuffer byteBuffer = ByteBuffer.allocateDirect(cubeCoors.length * 4);
        byteBuffer.order(ByteOrder.nativeOrder());
        //将坐标数据转换为FloatBuffer，用以传入给OpenGL ES程序
        vertexBuffer = byteBuffer.asFloatBuffer();
        //将三角形坐标传入FloatBuffer
        vertexBuffer.put(cubeCoors);
        vertexBuffer.position(0);

        //申请底层空间
        ByteBuffer colorBuffer = ByteBuffer.allocateDirect(color.length * 4);
        colorBuffer.order(ByteOrder.nativeOrder());
        colorFloatBuffer = colorBuffer.asFloatBuffer();
        colorFloatBuffer.put(color);
        colorFloatBuffer.position(0);

        ByteBuffer indexBuffer = ByteBuffer.allocateDirect(index.length * 2);
        indexBuffer.order(ByteOrder.nativeOrder());
        indexShortBuffer = indexBuffer.asShortBuffer();
        indexShortBuffer.put(index);
        indexShortBuffer.position(0);

        //创建顶点着色器程序
        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertextShaderCode);
        //创建片元着色器程序
        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

        if (vertexShader == 0 || fragmentShader == 0)
        {
            return;
        }
        //创建一个空的OpenGL ES程序
        program = GLES20.glCreateProgram();
        //将顶点着色器加入程序
        GLES20.glAttachShader(program, vertexShader);
        //将片元着色器加入程序
        GLES20.glAttachShader(program, fragmentShader);
        //连接到着色器程序中
        GLES20.glLinkProgram(program);
        //使用程序
        GLES20.glUseProgram(program);

    }

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

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

        float ratio = (float) width/height;

        //设置透视矩阵
        Matrix.frustumM(mProjectMatrix,0,-ratio,ratio,-1,1,3,20);
        //设置相机位置
        Matrix.setLookAtM(mViewMatrix,0,5.0f, 5.0f, 10.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
        //计算变换矩阵
        Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);


    }

    @Override
    public void onDrawFrame(GL10 gl)
    {
        if(program == 0)
            return;

        //获取变换矩阵vMatrix成员句柄
        int vMatrix = GLES20.glGetUniformLocation(program,"vMatrix");
        //设置vMatrix的值
        GLES20.glUniformMatrix4fv(vMatrix,1,false,mMVPMatrix,0);
        //获取顶点着色器的vPosition成员句柄
        int vPosition = GLES20.glGetAttribLocation(program, "vPosition");
        //启用vPosition句柄
        GLES20.glEnableVertexAttribArray(vPosition);
        //传的坐标数据
        GLES20.glVertexAttribPointer(vPosition,3,GLES20.GL_FLOAT,false,3*4, vertexBuffer);
        //获取顶点着色器的vColor成员句柄
        int aColor = GLES20.glGetAttribLocation(program, "aColor");
        //启用aColor句柄
        GLES20.glEnableVertexAttribArray(aColor);
        //设置绘制三角形的颜色
        GLES20.glVertexAttribPointer(aColor,4,GLES20.GL_FLOAT,false,4*4,colorFloatBuffer);
        //绘制三角形
        GLES20.glDrawElements(GLES20.GL_TRIANGLES,index.length,GLES20.GL_UNSIGNED_SHORT,indexShortBuffer);



        //禁止顶点数组的句柄
        GLES20.glDisableVertexAttribArray(vPosition);
    }

    public int loadShader(int type , String shaderCode)
    {
        //创建空的着色器
        int shader = GLES20.glCreateShader(type);
        //将着色器程序加到着色器中
        GLES20.glShaderSource(shader,shaderCode);
        //编译色器程序
        GLES20.glCompileShader(shader);

        return shader;

    }
}