【我的安卓进阶之旅】Opengl Es(4)之绘制正方体（附Github地址）

之前的博文我们都是在平面上绘制二维图形。接下来我们来学习绘制三维图形

构建立方体

上篇博客讲到正方形的绘制，立方体是是由六个正方形组成，我们将这六个正方形绘制出来，立方体就绘制完毕了。我们选择用索引法来绘制，立方体拥有八个顶点，我们先将这八个顶点列出来，放到一个数组中：

final float cubePositions[] = {
            -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
    };
 
 

 
 
1
2
3
4
5
6
7
8
9
10

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

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

 
 
1
2
3
4
5
6
7
8

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

//八个顶点的颜色，与顶点坐标一一对应
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,
    };
 
 

 
 
1
2
3
4
5
6
7
8
9
10
11

绘制立方体

确定好立方体坐标和颜色后，我们需要创建顶点着色器和片元着色器，可使用与Android OpenGLES2.0（三）——等腰直角三角形和彩色的三角形中彩色三角形相同的顶点着色器和片元着色器。
接着其他的步骤与绘制三角形相同：

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

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

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

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

（1）什么是深度？
深度其实就是该象素点在3d世界中距离摄象机的距离（绘制坐标），深度缓存中存储着每个象素点（绘制在屏幕上的）的深度值！
深度值（Z值）越大，则离摄像机越远。
深度值是存贮在深度缓存里面的，我们用深度缓存的位数来衡量深度缓存的精度。深度缓存位数越高，则精确度越高，目前的显卡一般都可支持16位的Z Buffer，一些高级的显卡已经可以支持32位的Z Buffer，但一般用24位Z Buffer就已经足够了。
（2）为什么需要深度？
在不使用深度测试的时候，如果我们先绘制一个距离较近的物体，再绘制距离较远的物体，则距离远的物体因为后绘制，会把距离近的物体覆盖掉，这样的效果并不是我们所希望的。而有了深度缓冲以后，绘制物体的顺序就不那么重要了，都能按照远近（Z值）正常显示，这很关键。
实际上，只要存在深度缓冲区，无论是否启用深度测试，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 Cube extends Shape {

    private int mProgramId;

    private int mPositionId,mMatrixHandler, mColorId;

    //设置每个顶点的坐标数
    private static final int COORDS_PER_VERTEX = 3;
    //每个float类型变量为4字节
    private final int VERTEX_STRID = COORDS_PER_VERTEX * 4;

    //folat缓冲区
    public FloatBuffer vertexBuffer,colorBuffer;
    public ShortBuffer indexBuffer;

    final float cubePositions[] = {
            -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 final int VERTEX_COUNT = cubePositions.length / COORDS_PER_VERTEX;

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

    //八个顶点的颜色，与顶点坐标一一对应
    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,
    };


    //顶点着色器
    public static final String VERTEX_SHADER =
                    "//根据所设置的顶点数据，插值在光栅化阶段进行\n" +
                    "attribute vec4 vPosition;" +
                    "uniform mat4 vMatrix;"+
                    "varying  vec4 vColor;" +
                    "attribute vec4 aColor;"+
                    "void main() {" +
                    "  //设置最终坐标\n" +
                    "  gl_Position = vMatrix*vPosition;" +
                    "vColor=aColor;"+
                    "}";


    //片元着色器
    public static final String FRAGMENT_SHADER =
                    "//设置float类型默认精度，顶点着色器默认highp，片元着色器需要用户声明\n" +
                    "precision mediump float;" +
                   "//颜色值，varying是从顶点着色器传递过来的\n" +
                    "varying vec4 vColor;" +
                    "void main() {" +
                    "//该片元最终颜色值\n" +
                    "  gl_FragColor = vColor;" +
                    "}";


    private float[] mProjectMatrix= new float[16];
    private float[] mViewMatrix= new float[16];
    private float[] mMVPMatrix= new float[16];

    public Cube() {

    }

    @Override
    public void onSurfaceCreated(GL10 gl, EGLConfig config) {
        //开启深度测试
        GLES20.glEnable(GLES20.GL_DEPTH_TEST);

        mProgramId = loadProgram(VERTEX_SHADER, FRAGMENT_SHADER);
        //通过OpenGL程序句柄查找获取顶点着色器中的位置句柄
        mPositionId = GLES20.glGetAttribLocation(mProgramId, "vPosition");
        //获取片元着色器的vColor成员的句柄
        mColorId = GLES20.glGetAttribLocation(mProgramId, "aColor");
        //通过OpenGL程序句柄查找获取片元着色器中的颜色句柄
        mMatrixHandler = GLES20.glGetUniformLocation(mProgramId, "vMatrix");
        // 初始化顶点字节缓冲区，用于存放形状的坐标，每个浮点数占用4个字节
        ByteBuffer bb = ByteBuffer.allocateDirect(cubePositions.length * 4);
        //设置使用设备硬件的原生字节序
        bb.order(ByteOrder.nativeOrder());
        //从ByteBuffer中创建一个浮点缓冲区
        vertexBuffer = bb.asFloatBuffer();
        // 把坐标都添加到FloatBuffer中
        vertexBuffer.put(cubePositions);
        //设置buffer从第一个坐标开始读
        vertexBuffer.position(0);


        // 给颜色缓冲区赋值
        ByteBuffer cb = ByteBuffer.allocateDirect(color.length * 4);
        cb.order(ByteOrder.nativeOrder());
        colorBuffer = cb.asFloatBuffer();
        colorBuffer.put(color);
        colorBuffer.position(0);

        // 初始化顶点字节缓冲区，用于存放形状的坐标，每个浮点数占用4个字节
        ByteBuffer ib = ByteBuffer.allocateDirect(index.length * 4);
        //设置使用设备硬件的原生字节序
        ib.order(ByteOrder.nativeOrder());
        //从ByteBuffer中创建一个浮点缓冲区
        indexBuffer = ib.asShortBuffer();
        // 把坐标都添加到FloatBuffer中
        indexBuffer.put(index);
        //设置buffer从第一个坐标开始读
        indexBuffer.position(0);

    }

    @Override
    public void onSurfaceChanged(GL10 gl, int width, int height) {
        //计算宽高比
        float ratio=(float)width/height;
        //设置透视投影
        Matrix.frustumM(mProjectMatrix, 0, -ratio, ratio, -1, 1, 3, 10);
        //设置相机位置
        Matrix.setLookAtM(mViewMatrix, 0, 3, 3, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
        //设置相机位置
        //Matrix.setLookAtM(mViewMatrix, 0, 0, 0, 7.0f, 0f, 0f, 0f, 0f, 1.0f, 0.0f);
        // 计算变换矩阵
        Matrix.multiplyMM(mMVPMatrix,0,mProjectMatrix,0,mViewMatrix,0);

    }

    @Override
    public void onDrawFrame(GL10 gl) {
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT|GLES20.GL_DEPTH_BUFFER_BIT);
        //告知OpenGL所要使用的Program
        GLES20.glUseProgram(mProgramId);
        //启用指向顶点数据的句柄
        GLES20.glEnableVertexAttribArray(mPositionId);
        //绑定坐标数据
        GLES20.glVertexAttribPointer(mPositionId, COORDS_PER_VERTEX,
                GLES20.GL_FLOAT, false,
                VERTEX_STRID, vertexBuffer);

        //启用指向颜色数据的句柄
        GLES20.glEnableVertexAttribArray(mColorId);
        //绑定颜色数据
        GLES20.glVertexAttribPointer(mColorId, 4,
                GLES20.GL_FLOAT, false,
                0, colorBuffer);

        //指定vMatrix的值
        GLES20.glUniformMatrix4fv(mMatrixHandler,1,false,mMVPMatrix,0);

        //索引法绘制
        GLES20.glDrawElements(GLES20.GL_TRIANGLES,index.length, GLES20.GL_UNSIGNED_SHORT,indexBuffer);
        //禁用顶点数据
        GLES20.glDisableVertexAttribArray(mPositionId);
    }

    @Override
    public void destroy() {
        GLES20.glDeleteProgram(mProgramId);
    }
}

源码

附上github下载地址