---

 

 

 

—————————————————————————————————————-

————————————————————————————————————————

常用的色彩格式

常见的色彩格式主要分为两类，一类是RGBA系列，一类是YUV系列。
RGBA系列

首先就是rgba系列的格式，RGBA色彩主要用于色彩的显示和描述。常见的有RGBA/ARGB/BGRA/ABGR/RGB/BGR。这些格式都比较好理解了。R、G、B、A分别表示红绿蓝及透明通道。
以RGBA为例，就是4个字节表示一个颜色值，排列方式就是RGBARGBARGBA这样排列。而RGB，就是三个字节表示一个颜色值，没有透明通道，排列方式就是RGBRGBRGB。在通常的视频中，也是没有透明通道的（也有例外，比如MOV格式，是可以包含透明通道的）。所以当RGBA编码为视频色彩时，A是会被丢掉的。
当然，上面说的，是将每个色彩都用一个字节来表示的情况。RGBA也有RGBA_8888，RGBA_4444,RGB565等等众多格式，也就是并不是每个颜色都用一个字节来表示。以RGB565为例，是用两个字节来表示RGB三个色彩，R占5位，G占6位，B占5位。RGB565与RGB24相比，色彩上稍有损失，一般情况下，不细致对比，不容易发现这个损失，但是内存上会节约1/3的大小。
YUV系列

YUV主要用于优化彩色视频信号的传输，相比RGBA色彩来说，YUV格式占用更少的内存。YUV系列的格式，与RGBA一样，也是五花八门，常见的有YUY2、YUYV、YVYU、UYVY、AYUV、Y41P、Y411、Y211、IF09、IYUV、YV12、YVU9、YUV411、YUV420、YUV422等等。Y表示亮度，U、V都表示色度。如果只有Y分量，没有UV分量，那么得到的就是黑白灰度图像。
与YUV类似的还有YCrCb，YIQ等色彩格式。YIQ模型与YUV模型类似，用于NTSC制式的电视系统。YIQ颜色空间中的I和Q分量相当于将YUV空间中的UV分量做了一个33度的旋转。而YCrCb是YUV的一种派生色彩，Y包含了绿色色度和亮度，Cr表示红色色度，Cb表示蓝色色度。
我们在实际使用时，遇到最多的大概就是NV21、NV12、YUV420P、YUV420SP、I420等这些格式。他们有什么区别呢？
实际上I420就是标准的YUV420P，以4*4的图像来说，YUV排列顺序为YYYYYYYYYYYYYYYYUUUUVVVV。YUV大小分别为4*4、2*2、2*2。
Y1Y2Y7Y8U1V1 可以表示四个像素点，其他的同色区域一样，都是表示四个像素点，像素位置与Y对应。
借用Wiki上的图片表示下：
这里写图片描述
NV21为标准的YUV420SP，以4*4的图像来说，YUV排列顺序为YYYYYYYYYYYYYYYYUVUVUVUV。Y大小分别为4*4、UV大小为4*2。如图：
这里写图片描述
NV12与NV21类似，也是YUV420SP，只是排列顺序上UV换了个边，变为YYYYYYYYYYYYYYYYVUVUVUVU。
当然像YUV411，YUV420对比，差异主要在于采样点上。YUV虽然格式众多，但是使用起来也是大同小异。更多可参考Wiki上的YUV介绍。
常用RGB与YUV之间的转换

很多时候，我们在网上找RGB转YUV格式或者YUV转RGB格式的转换公式时，总会得到不一样的公式，让我们无法选择，不知道哪个是正确的。实际上，RGB转YUV或者YUV转RGB的确会有不同的公式。这是由于不同的标准以及转换校正造成的。我们利用RGB转成YUV来传输，然后显示时又需要被还原成RGB。
根据BT.601标准（SDTV,标清），定义参数如下：

Wr=0.299
Wb=0.114
Wg=1-Wr-Wb=0.587
Umax=0.436
Vmax=0.615

1
2
3
4
5

RGB转YUV公式如下：
Y‘=WrR+WgG+WbB=0.299R+0.587G+0.114B

U=UmaxB−Y‘1−Wb≈0.492(B−Y‘)
V=VmaxR−Y‘1−Wr≈0.877(R−Y‘)

反向推导YUV转RGB的，得到公式如下：

R=Y‘+1.14V

G=Y‘−0.395U−0.581V
B=Y‘+2.033U

即得到RGB和YUV根据BT.601标准的公式为：

#RGB转YUV
#[Y] [0.299 0.587 0.114 ][R]
#[U] = [-0.147 -0.289 0.436 ][G]
#[V] [0.615 -0.515 -0.100 ][B]
Y = 0.299 R + 0.587 G + 0.114 B
U = -0.147 R – 0.289 G + 0.436 B
V = 0.615 R – 0.515 G – 0.100 B
#YUV转RGB
#[R] [1 0 1.140 ][Y]
#[G] = [1 -0.395 -0.581 ][U]
#[B] [1 2.032 0 ][V]
R = Y + 1.402 V
G= Y – 0.395 U – 0.581V
B= Y + 2.032U

# 在老式的非SIMD体系结构中，浮点运算慢与定点运算，所以变换下：
# RGB转YUV，studio-swing，Y的范围为[16-235],UV的范围为[16-240]
Y = ((66R+129G+25B+128)>>8)+16
U = ((-38R-74G+112B+128)>>8)+128
V = ((112R-94G-18B+128)>>8)+128

# RGB转YUV，full-swing，YUV的范围都为[0-255]
Y = (77R+150G+29B+128)>>8
U = (-43R-84G+127B+128)>>8)+128
V = ((127R-106G-21B+128)>>8)+128

# YUV转RGB
C = Y-16
D = U-128
E = V-128
R = clamp((298*C + 409 * E +128)>>8)
G = clamp((298*C – 100* D – 208* E+ 128)>>8)
B = clamp((298*C + 516* D- 128)>>8)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34

RGBA转YUV具体实现，可参考Android视频编码——RGBA、RGB、BGRA、BGR转YUV420P、YUV420SP
libyuv的使用

libyuv提供了非常方面好用的色彩空间转换、旋转、缩放的功能，转换效率也非常高。如果有色彩空间转换、旋转、缩放等功能的需求，不妨使用此库来完成。在使用libyuv进行转换或者自己写代码进行转换的过程中，可以使用RawGfx这个软件，来查看你的转换是否正确，无论是RGBA格式还是YUV格式的原始数据，都可以用它进行查看。
libyuv的jni封装

在libyuv中，提供了非常丰富的方法，我们实际使用时往往只需要使用到其中的一小部分。为了在Android中调用libyuv，我们需要编写Jni代码，调用libyuv中的方法。
以RGBA转I420为例，libyuv中提供了许多不同的方法来针对RGBA、ARGB、RGB565等等一系列的不同的RGBA格式转I420格式的方法。为了简化我们的工作我们可以做一个简单的封装来实现Java层调用RGBA转I420的方法。
我们可以先写出一个native的接口，来表述我们需要的功能：

public class YuvUtils {

//rgba也会有很多类型，所以我们加一个type的值，来表示rgba是什么类型
//也可以用直接写一个rgba转yuv的，rgba和yuv类型都不固定，用type来表示所有类型的rgba到yuv的转换
public static native int RgbaToI420(int type,byte[] rgba,byte[] yuv,int width,int height);

}

1
2
3
4
5
6
7
8

然后就是编写Jni代码了。
Jni代码中定义了一个函数指针数组，包含将会对Java提供的RGBA转I420的类型，值得注意的是在Java层传入byte[]以RGBA顺序排列时，libyuv是用ABGR来表示这个排列，如果期望传入的数据是RGBA排列，使用libyuv是用libyuv::RGBAToI420这个方法，得到的YUV数据将是错误的数据。

#include <assert.h>
#include “libyuv.h”
#include “jni.h”
#include “android/log.h”

#define YUV_UTILS_JAVA “com/wuwang/libyuv/YuvUtils”

#ifdef __cplusplus
extern “C” {
#endif

static int (*rgbaToI420Func[])(const uint8 *,int,uint8 *,int,uint8 *,int ,uint8 *,int,int,int)={
libyuv::ABGRToI420,libyuv::RGBAToI420,libyuv::ARGBToI420,libyuv::BGRAToI420,
libyuv::RGB24ToI420,libyuv::RGB565ToI420
};

int rgbaToI420(JNIEnv * env,jclass clazz,jbyteArray rgba,jint rgba_stride,
jbyteArray yuv,jint y_stride,jint u_stride,jint v_stride,
jint width,jint height,
int (*func)(const uint8 *,int,uint8 *,int,uint8 *,int ,uint8 *,int,int,int)){
size_t ySize=(size_t) (y_stride * height);
size_t uSize=(size_t) (u_stride * height >> 1);
jbyte * rgbaData= env->GetByteArrayElements(rgba,JNI_FALSE);
jbyte * yuvData=env->GetByteArrayElements(yuv,JNI_FALSE);
int ret=func((const uint8 *) rgbaData, rgba_stride, (uint8 *) yuvData, y_stride,
(uint8 *) (yuvData) + ySize, u_stride, (uint8 *) (yuvData )+ ySize + uSize,
v_stride, width, height);
env->ReleaseByteArrayElements(rgba,rgbaData,JNI_OK);
env->ReleaseByteArrayElements(yuv,yuvData,JNI_OK);
return ret;
}

int Jni_RgbaToI420(JNIEnv * env,jclass clazz,jint type,jbyteArray rgba,jbyteArray yuv,jint width,jint height){
uint8 cType=(uint8) (type & 0x0F);
int rgba_stride= ((type & 0xF0) >> 4)*width;
int y_stride=width;
int u_stride=width>>1;
int v_stride=u_stride;
return rgbaToI420(env,clazz,rgba,rgba_stride,yuv,y_stride,u_stride,v_stride,width,height,rgbaToI420Func[cType]);
}

//libyuv中，rgba表示abgrabgrabgr这样的顺序写入文件，java使用的时候习惯rgba表示rgbargbargba写入文件
static JNINativeMethod g_methods[]={
{“RgbaToI420″,”(I[B[BII)I”, (void *)Jni_RgbaToI420},
//…. 其他方法映射
};

JNIEXPORT jint JNI_OnLoad(JavaVM *vm, void *reserved)
{
JNIEnv* env = nullptr;

if (vm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
return JNI_ERR;
}
assert(env != nullptr);
jclass clazz=env->FindClass(YUV_UTILS_JAVA);
env->RegisterNatives(clazz, g_methods, (int) (sizeof(g_methods) / sizeof((g_methods)[0])));

return JNI_VERSION_1_4;
}

JNIEXPORT void JNI_OnUnload(JavaVM *jvm, void *reserved){
JNIEnv* env = nullptr;

if (jvm->GetEnv((void**)&env, JNI_VERSION_1_4) != JNI_OK) {
return;
}
jclass clazz=env->FindClass(YUV_UTILS_JAVA);
env->UnregisterNatives(clazz);
}

#ifdef __cplusplus
}
#endif

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75

传入的type，被每4位表示一个具体的意义。从低位到高位，0-3 表示转换类型，4-7 表示rgba_stride的宽度的倍数，8-11 表示yuv_stride宽度移位数，12-15 表示uv左移位数。
根据Jni代码中对于type各位的解析与使用，定义出类型转换的几个常量如下。这样我们就封装了一个通用的rgba转I420的方法了。

public final class Key {

private Key(){};

//0-3 表示转换类型
//4-7 表示rgba_stride的宽度的倍数
//8-11 表示yuv_stride宽度移位数
//12-15 表示uv左移位数

public static final int RGBA_TO_I420=0x01001040;
public static final int ABGR_TO_I420=0x01001041;
public static final int BGRA_TO_I420=0x01001042;
public static final int ARGB_TO_I420=0x01001043;
public static final int RGB24_TO_I420=0x01001034;
public static final int RGB565_TO_I420=0x01001025;

}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17

封装后的方法使用与检验

封装后的方法使用也比较简单，直接获取一个Bitmap，然后将Bitmap中的rgba数据copy出来，进行转换就可以了，转换完的结果保存到文件中，然后用RawGfx来检查下转换的结果是否正确。

Bitmap bitmap= BitmapFactory.decodeResource(getResources(),R.mipmap.bg);
width=bitmap.getWidth();
height=bitmap.getHeight();
File file=new File(getExternalFilesDir(null).getAbsolutePath()+”/cache.yuv”);
OutputStream os = new FileOutputStream(file);
ByteBuffer buffer=ByteBuffer.allocate(bitmap.getWidth()*bitmap.getHeight()*4);
bitmap.copyPixelsToBuffer(buffer);
byte[] yuvData=new byte[bitmap.getWidth()*bitmap.getHeight()*3/2];
YuvUtils.RgbaToI420(Key.RGBA_TO_I420,buffer.array(),yuvData,bitmap.getWidth(),bitmap.getHeight());
//rgbToYuv(buffer.array(),bitmap.getWidth(),bitmap.getHeight(),yuvData);
Log.e(“wuwang”,”width*height:”+bitmap.getWidth()+”/”+bitmap.getHeight());
os.write(yuvData);
os.flush();
os.close();

1
2
3
4
5
6
7
8
9
10
11
12
13
14

如下所示，是使用libyuv中的libyuv::RGBAToI420转换得到的结果：
这里写图片描述

由于上面说过，libyuv表示的排列顺序和Bitmap的RGBA表示的顺序是反向的。所以实际要调用libyuv::ABGRToI420才能得到正确的结果。

这里写图片描述
示例代码下载

libyuv提供了丰富的功能，其他功能使用与这个差不多，在github上的示例代码中有其他常用的转换、缩放、旋转等方法。有需要的可自行下载。
————————————————
版权声明：本文为CSDN博主「湖广午王」的原创文章，遵循CC 4.0 BY-SA版权协议，转载请附上原文出处链接及本声明。
原文链接：https://blog.csdn.net/junzia/article/details/76315120

 

 

————————————————————————————————————————

http://blog.csdn.net/oshunz/article/details/50171931

前面有一篇探讨了如何在片段着色器中将YUV数据转换为RGB数据并显示，但采用samplerExternalOES将SurfaceTexture作为OpenGL外部纹理，需要使用GL_TEXTURE_EXTERNAL_OES作为纹理模板，通过SetPreviewTexture将Camera数据图像输出到SurfaceTexture，调用updateTexImage()时将对应纹理更新为最新的一帧，然后通知OpenGL绘制对应纹理。

1.创建纹理ID

2.根据纹理id创建SurfaceTexture

3.更改Shader

顶点着色器与之前相比多了个textureTransform，用于接收SurfaceTexture变换矩阵，如果不需要也可以不盖被vertext shader。

片段着色器需要增加#extension GL_OES_EGL_image_external : require，因为第一步的纹理都绑定到GL_TEXTURE_EXTERNAL_OES

对应采样方式由Samlpe2D更改成samplerExternalOES。

4.绘制

与之前采用glTexImage2D绑定2D图像纹理不同，这里通过GLES20.glBindTexture(GLES11Ext.GL_TEXTURE_EXTERNAL_OES, textureid);绑定外部纹理即可。

如果使用了SurfaceTexture变换矩阵，可采用glUniformMatrix4fv传递给Shader

采用片段着色器方案的时间消耗主要在数据转移中，本方法的格式相关工作交给EGLImage处理，用到了Lock ANativeWindow。具体优劣尚未探讨，如有经验人士希望指点迷津。

 

 

 

 

 

GLSurfaceView是OpenGL中的一个类，也是可以预览Camera的，而且在预览Camera上有其独到之处。独到之处在哪？当使用Surfaceview无能为力、痛不欲生时就只有使用GLSurfaceView了，它能够真正做到让Camera的数据和显示分离，所以搞明白了这个，像Camera只开预览不显示这都是小菜，妥妥的。Android4.0的自带Camera源码是用SurfaceView预览的，但到了4.2就换成了GLSurfaceView来预览。如今到了4.4又用了自家的TextureView，所以从中可以窥探出新增TextureView的用意。

虽说Android4.2的Camera源码是用GLSurfaceView预览的，但是进行了大量的封装又封装的，由于是OpenGL小白，真是看的不知所云。俺滴要求不高，只想弄个可拍照的摸清GLSurfaceView在预览Camera上的使用流程。经过一番百度一无所获，后来翻出去Google一大圈也没发现可用的。倒是很多人都在用GLSurfaceView和Surfaceview同时预览Camera，Surfaceview用来预览数据，在上面又铺了一层GLSurfaceView绘制一些信息。无奈自己摸索，整出来的是能拍照也能得到数据，但是界面上不是一块白板就是一块黑板啥都不显示。后来在stackoverflow终于找到了一个可用的链接，哈哈，苍天啊，终于柳暗花明了！参考此链接，自己又改改摸索了一天才彻底搞定。之所以费这么多时间是不明白OpenGL ES2.0的绘制基本流程，跟简单的OpenGL的绘制还是稍有区别。下面上源码:

一、CameraGLSurfaceView.java 此类继承GLSurfaceView，并实现了两个接口

关于这个类进行简单说明:

1、Renderer这个接口里有三个回调: onSurfaceCreated() onSurfaceChanged() onDrawFrame(),在onSurfaceCreated里设置了GLSurfaceView的版本: setEGLContextClientVersion(2); 如果没这个设置是啥都画不出来了，因为Android支持OpenGL ES1.1和2.0及最新的3.0，而且版本间差别很大。不告诉他版本他不知道用哪个版本的api渲染。在设置setRenderer(this);后，再设置它的模式为RENDERMODE_WHEN_DIRTY。这个也很关键，看api：

When renderMode is RENDERMODE_CONTINUOUSLY, the renderer is called repeatedly to re-render the scene. When renderMode is RENDERMODE_WHEN_DIRTY, the renderer only rendered when the surface is created, or when requestRender is called. Defaults to RENDERMODE_CONTINUOUSLY.

Using RENDERMODE_WHEN_DIRTY can improve battery life and overall system performance by allowing the GPU and CPU to idle when the view does not need to be updated.

大意是RENDERMODE_CONTINUOUSLY模式就会一直Render，如果设置成RENDERMODE_WHEN_DIRTY，就是当有数据时才rendered或者主动调用了GLSurfaceView的requestRender.默认是连续模式，很显然Camera适合脏模式，一秒30帧，当有数据来时再渲染。

2、正因是RENDERMODE_WHEN_DIRTY所以就要告诉GLSurfaceView什么时候Render，也就是啥时候进到onDrawFrame()这个函数里。SurfaceTexture.OnFrameAvailableListener这个接口就干了这么一件事，当有数据上来后会进到

public void onFrameAvailable(SurfaceTexture surfaceTexture) {
// TODO Auto-generated method stub
Log.i(TAG, “onFrameAvailable…”);
this.requestRender();
}

这里，然后执行requestRender()。

3、网上有一些OpenGL ES的示例是在Activity里实现了SurfaceTexture.OnFrameAvailableListener此接口，其实这个无所谓。无论是被谁实现，关键看在回调里干了什么事。

4、与TextureView里对比可知，TextureView预览时因为实现了SurfaceTextureListener会自动创建SurfaceTexture。但在GLSurfaceView里则要手动创建同时绑定一个纹理ID。

5、本文在onSurfaceCreated()里打开Camera，在onSurfaceChanged()里开启预览，默认1.33的比例。原因是相比前两种预览，此处SurfaceTexture创建需要一定时间。如果想要开预览时由Activity发起，则要GLSurfaceView利用Handler将创建的SurfaceTexture传递给Activity。

二、DirectDrawer.java 此类非常关键，负责将SurfaceTexture内容绘制到屏幕上

三、有了上面两个类就完成95%的工作，可以将GLSurfaceView看成是有生命周期的。在onPause里进行关闭Camera，在Activity里复写两个方法:

这个glSurfaceView.bringToFront();其实不写也中。在布局里写入自定义的GLSurfaceView就ok了:

CameraActivity里只负责UI部分，CameraGLSurfaceView负责开Camera、预览，并调用DirectDrawer里的draw()进行绘制。其他代码就不上了。

注意事项:

1、在onDrawFrame()里，如果不调用mDirectDrawer.draw(mtx);是啥都显示不出来的！！！这是GLSurfaceView的特别之处。为啥呢？因为GLSurfaceView不是Android亲生的，而Surfaceview和TextureView是。所以得自己按照OpenGL ES的流程画。

2、究竟mDirectDrawer.draw(mtx)里在哪获取的Buffer目前杂家还么看太明白，貌似么有请求buffer，而是根据GLSurfaceView里创建的SurfaceTexture之前，生成的有个纹理ID。这个纹理ID一方面跟SurfaceTexture是绑定在一起的，另一方面跟DirectDrawer绑定，而SurfaceTexture作渲染载体。

3、参考链接里有,有人为了解决问题，给出了下面三段代码:

@Override
public void onDrawFrame(GL10 gl)
{
    float[] mtx = new float[16];
    mSurface.updateTexImage();
    mSurface.getTransformMatrix(mtx);    

    mDirectVideo.draw(mtx);
}

 private float[] transformTextureCoordinates( float[] coords, float[] matrix)
 {          
    float[] result = new float[ coords.length ];        
    float[] vt = new float[4];      

    for ( int i = 0 ; i < coords.length ; i += 2 ) {
        float[] v = { coords[i], coords[i+1], 0 , 1  };
        Matrix.multiplyMV(vt, 0, matrix, 0, v, 0);
        result[i] = vt[0];
        result[i+1] = vt[1];
    }
    return result;
 }

textureVerticesBuffer.clear();
textureVerticesBuffer.put( transformTextureCoordinates( textureVertices, mtx ));
textureVerticesBuffer.position(0);

我已经把代码都融入到了此demo，只不过在draw()方法里么有使用。原因是使用之后，得到的预览画面反而是变形的，而不用的话是ok的。上面的代码是得到SurfaceTexture的变换矩阵：mSurface.getTransformMatrix

然后将此矩阵传递给draw()，在draw的时候对textureVerticesBuffer作一个变化，然后再画。

下图是未加这个矩阵变换效果时:

下图为使用了变换矩阵，划片扭曲的还真说不上来咋扭曲的，但足以说明OpenGL ES在渲染效果上的强大，就是设置了个矩阵，不用一帧帧处理，就能得到不一样显示效果。

—————————–本文系原创，转载请注明作者yanzi1225627

版本号:PlayCamera_V3.0.0[2014-6-22].zip

CSDN下载链接:http://download.csdn.net/detail/yanzi1225627/7547263

百度云盘:

附个OpenGL ES简明教程：http://www.apkbus.com/android-20427-1-1.html

 

 

 

 

 

 

一、设置OpenGL ES视图

设置OpenGL视图并不难，Android上也较简单。我们一般只需要2个步骤。

GLSurfaceView

我们要为GLSurfaceView提供一个专门用于渲染的接口

public void  setRenderer(GLSurfaceView.Renderer renderer)

 

GLSurfaceView.Renderer

GLSurfaceView.Renderer是一个通用渲染接口。我们必须实现下面的三个抽象方法：

// 画面创建

public void onSurfaceCreated(GL10 gl, EGLConfig config)

// 画面绘制

public void onDrawFrame(GL10 gl)

// 画面改变

public void onSurfaceChanged(GL10 gl, int width, int height)

onSurfaceCreated

在这里我们主要进行一些初始化工作，比如对透视进行修正、设置清屏所用颜色等。

onDrawFrame

绘制当前画面

onSurfaceChanged

当设备水平或者垂直变化时调用此方法，设置新的显示比例

 

案例代码：

 

1. public class OpenGLDemo extends Activity {
2.     @Override
3.     public void onCreate(Bundle savedInstanceState) {
4.         GLSurfaceView view = new GLSurfaceView(this);
5.         view.setRenderer(new OpenGLRenderer());
6.         setContentView(view);
7.     }
8. }

复制代码

实现renderer需要更多的设置

1.     public void onSurfaceCreated(GL10 gl, EGLConfig config) {
2.         // 黑色背景
3.         gl.glClearColor(0.0f, 0.0f, 0.0f, 0.5f);
4.         // 启用阴影平滑（不是必须的）
5.         gl.glShadeModel(GL10.GL_SMOOTH);
6.         // 设置深度缓存
7.         gl.glClearDepthf(1.0f);
8.         // 启用深度测试
9.         gl.glEnable(GL10.GL_DEPTH_TEST);
10.         // 所作深度测试的类型
11.         gl.glDepthFunc(GL10.GL_LEQUAL);
12.         // 对透视进行修正
13.         gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);
14.     }
16.     public void onDrawFrame(GL10 gl) {
17.         // 清除屏幕和深度缓存
18.         gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
19.     }
21.     public void onSurfaceChanged(GL10 gl, int width, int height) {
22.         // 设置画面的大小
23.         gl.glViewport(0, 0, width, height);
24.         // 设置投影矩阵
25.         gl.glMatrixMode(GL10.GL_PROJECTION);
26.         // 重置投影矩阵
27.         gl.glLoadIdentity();
28.         // 设置画面比例
29.         GLU.gluPerspective(gl, 45.0f, (float) width / (float) height, 0.1f,100.0f);
30.         // 选择模型观察矩阵
31.         gl.glMatrixMode(GL10.GL_MODELVIEW);
32.         // 重置模型观察矩阵
33.         gl.glLoadIdentity();
34.     }
35. }

复制代码

只要加入这段代码到OpenGLDemo class里就可实现全屏this.requestWindowFeature(Window.FEATURE_NO_TITLE);
getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
WindowManager.LayoutParams.FLAG_FULLSCREEN);
设置完视图后，即可编译运行，可以看到一个“漂亮”的黑屏 = =！

OpenGLDemo01.rar (48.38 KB, 下载次数: 259)

 

二、绘制多边形前面的教程都是关于设置GLSurfaceView.的，接下来的教程将教我们渲染出一个多边形。3D模型用较小的元素创建（点，边，面），他们可以被分别操作。
顶点

 

在Android中，我们通过float数组定义顶点，并将它放到字节型缓冲区内来获取更好的性能。下例的代码即为上图所示顶点。OpenGL ES的很多功能都必须手动的开启和关闭。

1. gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
2. // 设置顶点数据，3代表XYZ坐标系
3. gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
4. // 关闭顶点设置
5. gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);

复制代码

边

面

计算多边形面的时候，一定要注意正确的方向.。因为这将决定哪一面为正面哪一面为背面。 所以我们尽量保证整个项目都使用相同的环绕。gl.glFrontFace(GL10.GL_CCW);控制多边形的正面是如何决定的。在默认情况下，mode是GL_CCW。mode的值为： 　　GL_CCW 表示窗口坐标上投影多边形的顶点顺序为逆时针方向的表面为正面。 　　GL_CW 表示顶点顺序为顺时针方向的表面为正面。顶点的方向又称为环绕。gl.glEnable(GL10.GL_CULL_FACE);gl.glCullFace(GL10.GL_BACK);剔除多边形的背面，禁用多边形背面上的光照、阴影和颜色计算及操作。gl.glDisable(GL10.GL_CULL_FACE);
多边形

到了绘制面的时候了， 我们使用默认的逆时针环绕。下例代码将绘制上图多边形。

1.     // 将坐标数组放入字节缓存中
2.     // (1) 分配缓存，一个short为2个字节，所以要乘以2
3.     ByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);
4.     // (2) 设置字节处理规则
5.     ibb.order(ByteOrder.nativeOrder());
6.     // (3) 转换为short型字符
7.     ShortBuffer indexBuffer = ibb.asShortBuffer();
8.     // (4) 放入坐标数组
9.     indexBuffer.put(indices);
10.     // (5) 复位
11.     indexBuffer.position(0);

复制代码

渲染是时候弄些玩意儿到屏幕上去了，绘制时我们将用到两个函数public abstract void glDrawArrays(int mode, int first, int count)通过我们构造的顶点缓存来绘制顶点public abstract void glDrawElements(int mode, int count, int type, Buffer indices)和glDrawArrays类似，但需要直接传入type（索引值的类型，如GL_UNSIGNED_SHORT, or GL_UNSIGNED_INT），和indices（索引缓存）两者的共同点是，都必须知道他们需要画什么。怎样渲染图元，有不同方式，为了帮助调试，我们应该了解它们。
Mode：GL_POINTS绘制独立的点到屏幕

GL_LINE_STRIP连续的连线，第n个顶点与第n-1个顶点绘制一条直线

GL_LINE_LOOP和上面相同，但首尾相连

GL_LINES各对独立的线段

GL_TRIANGLES各个独立的三角形

GL_TRIANGLE_STRIP
绘制一系列的三角形，先是顶点 v0, v1, v2, 然后是 v2, v1, v3 (注意规律), 然后v2, v3, v4等。该规律确保所有的三角形都以相同的方向绘制。

GL_TRIANGLE_FAN和GL_TRIANGLE_STRIP类似, 但其先绘制 v0, v1, v2, 再是 v0, v2, v3, 然后 v0, v3, v4等。
我认为GL_TRIANGLES是使用最方便的，所以我们将先使用它。

1. public class Square {
2.     // 顶点坐标数组
3.     private float vertices[] = { -1.0f, 1.0f, 0.0f, // 0, 左上
4.         -1.0f, -1.0f, 0.0f, // 1, 左下
5.         1.0f, -1.0f, 0.0f, // 2, 右下
6.         1.0f, 1.0f, 0.0f, // 3, 右上
7.     };
8.     // 连接规则
9.     private short[] indices = { 0, 1, 2, 0, 2, 3 };
10.     // 顶点缓存
11.     private FloatBuffer vertexBuffer;
12.     // 索引缓存
13.     private ShortBuffer indexBuffer;
16.     public Square() {
17.         // 一个float为4 bytes, 因此要乘以4
18.         ByteBuffer vbb = ByteBuffer.allocateDirect(vertices.length * 4);
19.         vbb.order(ByteOrder.nativeOrder());
20.         vertexBuffer = vbb.asFloatBuffer();
21.         vertexBuffer.put(vertices);
22.         vertexBuffer.position(0);
23.         // short类型同理
24.         ByteBuffer ibb = ByteBuffer.allocateDirect(indices.length * 2);
25.         ibb.order(ByteOrder.nativeOrder());
26.         indexBuffer = ibb.asShortBuffer();
27.         indexBuffer.put(indices);
28.         indexBuffer.position(0);
29.         }
31.     /**
32.      * 绘制正方形到屏幕
33.      *
34.      * @param gl
35.      */
36.     public void draw(GL10 gl) {
37.         // 逆时针环绕
38.         gl.glFrontFace(GL10.GL_CCW);
39.         // 开启剔除功能
40.         gl.glEnable(GL10.GL_CULL_FACE);
41.         // 剔除背面
42.         gl.glCullFace(GL10.GL_BACK);
43.         // 开启顶点缓存写入功能
44.         gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
45.         // 设置顶点
46.         // size:每个顶点有几个数指描述。
47.         // type:数组中每个顶点的坐标类型。
48.         // stride:数组中每个顶点间的间隔，步长（字节位移）。
49.         // pointer:存储着每个顶点的坐标值。初始值为0
50.         gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);
51.         gl.glDrawElements(GL10.GL_TRIANGLES, indices.length,
52.         GL10.GL_UNSIGNED_SHORT, indexBuffer);
53.         // 关闭各个功能
54.         gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);
55.         gl.glDisable(GL10.GL_CULL_FACE);
56.     }
57. }

复制代码

我们必须在OpenGLRenderer类中初始化square

1. square = new Square();<!–EndFragment–>

复制代码

并在主绘制方法中调用square的绘制方法

1. public void onDrawFrame(GL10 gl) {
2.     // 清除屏幕和深度缓存
3.     gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
4.     // 绘制正方形
5.     square.draw(gl);
6. }

复制代码

如果你现在运行应用，我们又看到了华丽的黑屏，为什么？因为OpenGL ES渲染默认的当前位置为(0,0,0)，窗口的定位也一样。而且OpenGL ES不渲染太靠近窗体定位的东西。解决方法就是移动绘制的位置。

1. gl.glTranslatef(0, 0, -4);  <!–EndFragment–>

复制代码

再次运行应用你将看到该正方形已经被绘制，但是它好像离我们越来越远一样，最后消失了。OpenGL ES不会在画面之间复位绘制点，所以我们要自己完成。

1. // 重置当前的模型观察矩阵
2. gl.glLoadIdentity();<!–EndFragment–>

复制代码

现在，我们运行应用将会看到一个固定位置的正方形。

OpenGLDemo02.rar (64.87 KB, 下载次数: 347)