Android高级进阶五 Android OpenGL给多边形着色

最新版本：Android高级进阶五 Android OpenGL给多边形着色

         上一节Android高级进阶四 Android OpenGL开发多边形完成了我们AndroidOpenGL开发的第一步，这一节我们接着上一节的步伐，谈谈如何在已经画好了的图像上进行着色。

        Android SDK至今已经提供了2中多边形着色方案，一个是平滑着色（smooth coloring），另一个则是单调着色（float coloring）。今天主要完成的任务是，将上一节的三角形进行平滑着色，而将四边形通过单调着色来进行着色。先上效果图：

        

        左边的三角形使用的是平滑着色，右边的四边形使用的是单调着色，我们一一来看，这些着色是怎么使用的。

        先看平滑着色--

        首先我们为三角形的每一个顶点设置一个颜色，每个顶点由4个数字组成(r、g、b、Alpha)，比如下面的代码即表示一个颜色数组：

1. private int one = 0x10000;  
2. private int[] color = {one, 0, 0, one,  
3.                                     0, one, 0, one,  
4.                                     0, 0, one, one,};  
5. //准备颜色  
6. private IntBuffer colorBuffer = BufferUtil.iBuffer(color); 

        这边再开启颜色渲染功能：

1. //对三角形进行平滑着色,需要开启颜色渲染  
2. gl.glEnableClientState(GL10.GL_COLOR_ARRAY);  

        再使用glColorPointer来为每一个顶点着色：

1. gl.glColorPointer(4, GL10.GL_FIXED, 0, colorBuffer);  

        最后再关闭颜色渲染功能：

1. //关闭平滑着色  
2. gl.glDisableClientState(GL10.GL_COLOR_ARRAY);

        单调着色就更简单了--

        直接在四边形的设置好定点之后使用glColor4系类着色：

1. //给四边行设置单调着色  
2. gl.glColor4f(0.5f, 0.5f, 1.0f, 1.0f); 

        完整代码如下：

1. package org.ourunix.android.opengltest;  
2.   
3. import java.nio.ByteBuffer;  
4. import java.nio.ByteOrder;  
5. import java.nio.IntBuffer;  
6.   
7. import javax.microedition.khronos.egl.EGLConfig;  
8. import javax.microedition.khronos.opengles.GL10;  
9.   
10. import android.app.Activity;  
11. import android.opengl.GLSurfaceView;  
12. import android.opengl.GLSurfaceView.Renderer;  
13. import android.os.Bundle;  
14.   
15. public class OpenGLTestActivity extends Activity {  
16.     /** Called when the activity is first created. */  
17.     @Override  
18.     public void onCreate(Bundle savedInstanceState) {  
19.         super.onCreate(savedInstanceState);  
20.        GLSurfaceView glView = new GLSurfaceView(this);  
21.        Renderer render = new GLRender();  
22.        glView.setRenderer(render);  
23.        setContentView(glView);  
24.     }  
25.       
26.     public class GLRender implements Renderer{  
27.         private int one = 0x10000;  
28.         private int[] trigger = {0, one, 0,   
29.                                 -one, -one, 0,   
30.                                 one, -one, 0};  
31.         private int[] quarter = {one, one, 0,   
32.                                 -one, one, 0,   
33.                                 one, -one, 0,  
34.                                 -one, -one, 0};  
35.         private int[] color = {one, 0, 0, one,  
36.                                     0, one, 0, one,  
37.                                     0, 0, one, one,};  
38.         //准备三角各顶点  
39.         private IntBuffer triggerBuffer = BufferUtil.iBuffer(trigger);  
40.         //准备四边顶点  
41.         private IntBuffer quarterBuffer = BufferUtil.iBuffer(quarter);   
42.         //准备颜色  
43.         private IntBuffer colorBuffer = BufferUtil.iBuffer(color);  
44.           
45.         //咳，咳现在开始画图了  
46.         @Override  
47.         public void onDrawFrame(GL10 gl) {  
48.             // TODO Auto-generated method stub  
49.             //清楚屏幕和深度缓存  
50.             gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);  
51.             gl.glLoadIdentity();  
52.             //现将屏幕向左移动，用来画三角形  
53.             gl.glTranslatef(-1.5f, 0.0f, -6.0f);  
54.             //允许设置顶点  
55.             gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);  
56.             //对三角形进行平滑着色,需要开启颜色渲染  
57.             gl.glEnableClientState(GL10.GL_COLOR_ARRAY);  
58.             gl.glColorPointer(4, GL10.GL_FIXED, 0, colorBuffer);  
59.             //设置三角形  
60.             gl.glVertexPointer(3, GL10.GL_FIXED, 0, triggerBuffer);  
61.             //绘制三角形  
62.             gl.glDrawArrays(GL10.GL_TRIANGLES, 0, 3);  
63.             //关闭平滑着色  
64.             gl.glDisableClientState(GL10.GL_COLOR_ARRAY);  
65.             //重置  
66.             gl.glLoadIdentity();  
67.             //现将屏幕向左移动，用来画四边形  
68.             gl.glTranslatef(1.5f, 0.0f, -6.0f);  
69.             //设置四边形  
70.             gl.glVertexPointer(3, GL10.GL_FIXED, 0, quarterBuffer);  
71.             //给四边行设置单调着色  
72.             gl.glColor4f(0.5f, 0.5f, 1.0f, 1.0f);  
73.             //绘制四边形  
74.             gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, 4);  
75.               
76.             gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);  
77.         }  
78.   
79.         //当窗口改变时，调用，至少在创建窗口时调用一次，这边设置下场景大小  
80.         @Override  
81.         public void onSurfaceChanged(GL10 gl, int width, int height) {  
82.             // TODO Auto-generated method stub  
83.             //设置OpenGL场景大小  
84.             float ratio = (float) width / height;  
85.             gl.glViewport(0, 0, width, height);  
86.             gl.glMatrixMode(GL10.GL_PROJECTION);//设置为投影矩阵模式  
87.             gl.glLoadIdentity();//重置  
88.             gl.glFrustumf(-ratio, ratio, -1, 1, 1, 10);//设置视角  
89.             gl.glMatrixMode(GL10.GL_MODELVIEW);  
90.             gl.glLoadIdentity();  
91.         }  
92.   
93.         //当窗口被创建时我们可以做些初始化工作  
94.         @Override  
95.         public void onSurfaceCreated(GL10 gl, EGLConfig config) {  
96.             // TODO Auto-generated method stub  
97.             //告诉系统对透视进行修正  
98.             gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST);  
99.             //设置清除屏幕时所用的颜色，参数依次为红、绿、蓝、Alpha值  
100.             gl.glClearColorx(0, 0, 0, 0);  
101.             //启用阴影平滑  
102.             gl.glShadeModel(GL10.GL_SMOOTH);  
103.             //以下是关于深度缓存的设置，非常重要  
104.             gl.glClearDepthf(1.0f);//设置深度缓存  
105.             gl.glEnable(GL10.GL_DEPTH_TEST);//启用深度测试  
106.             gl.glDepthFunc(GL10.GL_LEQUAL);//所做深度测试的类型  
107.         }  
108.           
109.     }  
110.       
111.     public static class BufferUtil {  
112.         public static IntBuffer intBuffer;  
113.   
114.         public static IntBuffer iBuffer(int[] a) {  
115.             // 先初始化buffer,数组的长度*4,因为一个float占4个字节  
116.             ByteBuffer mbb = ByteBuffer.allocateDirect(a.length * 4);  
117.             // 数组排列用nativeOrder  
118.             mbb.order(ByteOrder.nativeOrder());  
119.             intBuffer = mbb.asIntBuffer();  
120.             intBuffer.put(a);  
121.             intBuffer.position(0);  
122.             return intBuffer;  
123.         }  
124.     }  
125. }