很多教程都是在C/C++写的OpenGL的代码，其中有很多优秀的框架，除了前面提过的Assimp库外，还有很强大的库glm，从另外一个角度来看，在学习EGL的时候，很多的资料都是C语言的代码，我在android上写OpenGL ES的代码似乎从来没见过那些代码，不使用一下总觉得缺少点什么。
事实上，Android在native层构建OpenGL环境的步骤就如同前面博客OpenGL ES EGL介绍中讲过的这样，在Java层，与EGL相关的操作我们也看不到，其实都是由GLSurfaceView封装好了。
因此这篇博客就研究一下怎么使用Native代码写OpenGL ES代码和如何利用EGL自己创建OpenGL的环境。最终包含：
1.使用Native代码+GLSurfaceView写的六边形，这里会介绍到glm库。
2.Java代码自己写一个功能类似GLSurfaceView的类，主要是在java层使用EGL自己创建OpenGL的环境，思想上参考了GLSurfaceView的源码。
3.全部使用native代码写的六边形。Java层仅用了SurfaceView，余下的功能全部在native层实现。
先贴上效果图，这三幅图分别是上面描述的三个程序执行得到的结果。
第一幅图是第一篇写OpenGL入门的时候使用的Demo，我用本博客第二部分写的MySurfaceView替换了系统自带的GLSurfaceView执行的效果。
第一幅图和三幅图也是画一个六边形，只是没有旋转，大小并且都是用AndroidStudio创建的项目。
使用Native代码+GLSurfaceView
这种方式其实就是将GLSurfaceView.Renderer的几个回调函数在native层实现，算是体验C/C++写OpenGL代码的第一步吧。Render类大概就是下面的样子
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
String vetexShaderStr = LoadShaderStr(mContext, R.raw.vshader);
String fragmentShaderStr = LoadShaderStr(mContext, R.raw.fshader);
// native
nativeInit(vetexShaderStr, fragmentShaderStr);
}
@Override
public void onDrawFrame(GL10 gl) {
// native
nativeDraw(mAngleX, mAngleY);
}
@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
// native
nativeSurfaceChanged(width, height);
}
public static native void nativeInit(String vertexShaderCode, String fragmentShaderCode);
private static native void nativeDraw(float angleX, float angleY);
private static native void nativeSurfaceChanged(int width, int height);
}在native层要做的事情其实和前面用java语言写的代码是类似的，无外乎就是写一个六边形的类，函数名也是一致的，因此写起来很简单。
使用Java代码的时候在android.opengl包中有个很方便的类Matrix，里面封装了矩阵的相关操作，设置投影、摄像机矩阵、矩阵相乘等操作都被封装好了，在C/C++中可没有这个类，不过也不是难事。Android Native Development Kit Cookbook一书的作者就封装了相关操作。
#ifndef MATRIX_H
#define MATRIX_H
#include <math.h>
#define MYPI 3.14159265358979323846
void translate_matrix(float tx, float ty, float tz, float *M);
void scale_matrix(float xs, float ys, float zs, float *M);
void rotate_matrix(float angle, float x, float y, float z, float *M);
void perspective_matrix(float fovy, float aspect, float znear, float zfar, float *M);
void multiply_matrix(float *A, float *B, float *M);
#endif
#include "matrix.h"
//all matrix are in column-major order
//the 4x4 matrix are stored in an array as shown below
//0-15 indicates the array index
//0 4 8 12
//1 5 9 13
//2 6 10 14
//3 7 11 15
void load_identity(float *M) {
for (int i = 0; i < 16; ++i) {
M[i] = 0.0f;
}
M[0] = 1.0f;
M[5] = 1.0f;
M[10] = 1.0f;
M[15] = 1.0f;
}
//return translation matrix
// 1 0 0 tx
// 0 1 0 ty
// 0 0 1 tz
// 0 0 0 1
void translate_matrix(float tx, float ty, float tz, float *M) {
load_identity(M);
M[12] = tx;
M[13] = ty;
M[14] = tz;
}
//return scaling matrix
// sx 0 0 0
// 0 sy 0 0
// 0 0 sz 0
// 0 0 0 1
void scale_matrix(float sx, float sy, float sz, float *M) {
load_identity(M);
M[0] *= sx;
M[5] *= sy;
M[10] *= sz;
}
//return rotation matrix
//R = Rx*Ry*Rz
// 1 0 0 0
// Rx = 0 cosx -sinx 0
// 0 sinx cosx 0
// 0 0 0 1
// cosy 0 siny 0
// 0 1 0 0
// Ry =-siny 0 cosy 0
// 0 0 0 1
//
// cosz -sinz 0 0
// Rz= sinz cosz 0 0
// 0 0 1 0
// 0 0 0 1
//refer to http://lignumcad.sourceforge.net/doc/en/HTML/SOHTML/TechnicalReference.html
//for detailed info
void rotate_matrix(float angle, float x, float y, float z, float *M) {
double radians, c, s, c1, u[3], length;
int i, j;
radians = (angle * MYPI) / 180.0;
c = cos(radians);
s = sin(radians);
c1 = 1.0 - cos(radians);
length = sqrt(x * x + y * y + z * z);
u[0] = x / length;
u[1] = y / length;
u[2] = z / length;
for (i = 0; i < 16; i++) {
M[i] = 0.0;
}
M[15] = 1.0;
for (i = 0; i < 3; i++) {
M[i * 4 + (i + 1) % 3] = u[(i + 2) % 3] * s;
M[i * 4 + (i + 2) % 3] = -u[(i + 1) % 3] * s;
}
for (i = 0; i < 3; i++) {
for (j = 0; j < 3; j++) {
M[i * 4 + j] += c1 * u[i] * u[j] + (i == j ? c : 0.0);
}
}
}
/* simulate gluPerspectiveMatrix
* //return perspective projection matrix
* cot(fovy/2) / aspect 0 0 0
* 0 cot(fovy/2) 0 0
* 0 0 (znear+zfar)/(znear-zfar) 2*znear*zfa/(znear-zfar)
* 0 0 -1 0
*/
void perspective_matrix(float fovy, float aspect, float znear, float zfar, float *M) {
int i;
double f;
load_identity(M);
f = 1.0/tan(fovy * 0.5);
M[0] = f / aspect;
M[5] = f;
M[10] = (znear + zfar) / (znear - zfar);
M[11] = -1.0;
M[14] = (2.0 * znear * zfar) / (znear - zfar);
M[15] = 0.0;
}
//Multiplies A by B and output to C, a tmp buffer is used to support in-place multiplication
void multiply_matrix(float *A, float *B, float *C) {
int i, j, k;
float tmpM[16];
for (i = 0; i < 4; i++) {
for (j = 0; j < 4; j++) {
tmpM[j * 4 + i] = 0.0;
for (k = 0; k < 4; k++) {
tmpM[j * 4 + i] += A[k * 4 + i] * B[j * 4 + k];
}
}
}
for (i = 0; i < 16; i++) {
C[i] = tmpM[i];
}
}
不过我觉得这都是不必要的工作，很浪费时间，事实上有一个非常强大的数学库glm（OpenGL Mathematics
）主要还体现在它是为OpenGL开发人员量身定做的，和使用着色器语言一样，使用很方便。我在这个Demo中主要用了它的设置摄像机矩阵、投影矩阵。
#include "glm/mat4x4.hpp"
#include "glm/ext.hpp"
glm::mat4 projection;
glm::mat4 view;
//glm::mat4 module;
projection = glm::ortho(-1.0f, 1.0f, -(float) height / width, (float) height / width, 5.0f,
7.0f);
view = glm::lookAt(glm::vec3(0.0f, 0.0f, 6.0f),
glm::vec3(0.0f, 0.0f, 0.0f),
glm::vec3(0.0f, 1.0f, 0.0f));
// 矩阵相乘太方便
glm::mat4 mvpMatrix = projection * view/* * module*/;
// 装换成数组形式
float *mvp = (float *) glm::value_ptr(mvpMatrix);
mShape.draw(mvp);代码在这里：https://github.com/qhyuan1992/OpenGL-ES/tree/master/NativeGLESView
在Java层使用EGL
其实在利用OpenGL ES进行Android手游录屏研究这篇博客中已经接触到了Java层的EGL使用了，GLSurfaceView继承自SurfaceView，我们用它来写OpenGL代码很方便，就是因为它已经封装好了创建EGL环境的部分了，如果看GLSurfaceView的代码必然可以看到前面讲EGL部分的时候创建EGL环境的相关函数调用。
不过由于GLSurfaceView代码比较多，下面是我自己写的一个类似GLSurfaceView的类，写的很简略，用其来替代系统的GLSurfaceView即可。显然这样做用来了解Java层EGL的使用是足够的。
里面有部分代码我是参考GLSurfaceView的源码的。
package com.example.opengles_circle;
import java.lang.ref.WeakReference;
import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
import javax.microedition.khronos.egl.EGLSurface;
import android.content.Context;
import android.view.SurfaceHolder;
import android.view.SurfaceView;
public class MyGLSurfaceView extends SurfaceView implements SurfaceHolder.Callback{
public SurfaceHolder mHolder;
public Renderer mRenderer;
private final WeakReference<MyGLSurfaceView> mThisWeakRef = new WeakReference<MyGLSurfaceView>(this);
Object mLock = new Object();
private GLThread mThread;
public MyGLSurfaceView(Context context) {
super(context);
mHolder = getHolder();
mHolder.addCallback(this);
}
public void setRenderer(Renderer renderer) {
mRenderer = renderer;
mThread = new GLThread(mThisWeakRef);
mThread.start();
}
public void surfaceCreated(SurfaceHolder holder) {
mThread.surfaceCreated();
}
public void surfaceDestroyed(SurfaceHolder holder) {
mThread.surfaceDestroyed();
}
public void surfaceChanged(SurfaceHolder holder, int format, int w, int h) {
mThread.surfaceChanged(w, h);
}
public void stopRender() {
// 设置停止标示，notify
}
public interface Renderer {
void onSurfaceCreated();
void onSurfaceChanged(int width, int height);
void onDrawFrame();
}
}
class GLThread extends Thread {
private Object lock = new Object();
private EGLHelper mEglHelper;
private boolean mHasSurface = false;
public int mWidth;
public int mHeight;
private WeakReference<MyGLSurfaceView> mGLSurfaceViewWeakRef;
GLThread(WeakReference<MyGLSurfaceView> glSurfaceViewWeakRef) {
super();
mWidth = 0;
mHeight = 0;
mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
}
@Override
public void run() {
try {
doThread();
} catch (InterruptedException e) {
e.printStackTrace();
}
}
private void doThread() throws InterruptedException {
mEglHelper = new EGLHelper(mGLSurfaceViewWeakRef);
MyGLSurfaceView view = mGLSurfaceViewWeakRef.get();
// 确保有了Surface
synchronized (lock) {
if (!mHasSurface) {
lock.wait();
}
}
mEglHelper.start();
/*----实际上是在一个循环里面针对不同的事件(onSurfaceCreated/onSurfaceChanged/onDrawFrame/terminal)执行不同的回调----*/
/*-----所有情况都执行完后，wait，当某个事件发生后标志置位，然后调用notify----*/
view.mRenderer.onSurfaceCreated();
// 也要确保在surfaceChanged之后执行
view.mRenderer.onSurfaceChanged(mWidth, mHeight);
view.mRenderer.onDrawFrame();
mEglHelper.swap();
}
public void surfaceCreated() {
}
public void surfaceChanged(int w, int h) {
mWidth = w;
mHeight = h;
synchronized (lock) {
mHasSurface = true;
lock.notifyAll();
}
}
public void surfaceDestroyed() {
synchronized (lock) {
mHasSurface = false;
lock.notifyAll();
}
}
}
class EGLHelper{
public WeakReference<MyGLSurfaceView> mGLSurfaceViewWeakRef;
private EGL10 mEgl;
private EGLDisplay mEglDisplay;
private EGLConfig mEglConfig;
private EGLContext mEglContext;
private EGLSurface mEglSurface;
public EGLHelper(WeakReference<MyGLSurfaceView> glSurfaceViewWeakRef) {
mGLSurfaceViewWeakRef = glSurfaceViewWeakRef;
}
// start函数中就是创建EGL环境的步骤
public void start(){
int[] num_config = new int[1];
EGLConfig[] configs = new EGLConfig[1];
int[] configSpec = { EGL10.EGL_RED_SIZE, 8,
EGL10.EGL_GREEN_SIZE, 8,
EGL10.EGL_BLUE_SIZE, 8,
EGL10.EGL_SURFACE_TYPE, EGL10.EGL_WINDOW_BIT, EGL10.EGL_NONE };
this.mEgl = (EGL10) EGLContext.getEGL();
mEglDisplay = this.mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
this.mEgl.eglInitialize(mEglDisplay, null);
this.mEgl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, num_config);
mEglConfig = configs[0];
mEglSurface = this.mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig,
mGLSurfaceViewWeakRef.get().mHolder, null);
int[] attrs = {0x3098, 2, EGL10.EGL_NONE}; // EGL_CONTEXT_CLIENT_VERSION
mEglContext = this.mEgl.eglCreateContext(mEglDisplay, mEglConfig,
EGL10.EGL_NO_CONTEXT, attrs);
this.mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
}
public void swap() {
mEgl.eglSwapBuffers(mEglDisplay, mEglSurface);
}
public void destroySurface() {
if (mEglSurface != null) {
mEgl.eglMakeCurrent(mEglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEgl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
mEgl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
mEgl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}
}可以看到当调用setRender时就开启了一个子线程GLThread，不过这个线程没有立即执行而是wait直到surface创建成功。
EGLHelper就是一个工具类，里面的start函数就包含了创建EGL环境的步骤，等待EGL上下文创建好了，在执行 view.mRenderer.onDrawFrame();回调中其实就是我们要实现的部分，在里面进行OpenGL绘图，然后在执行EGLHelper的swap函数，将后台缓冲中的内容显示到native_window也就是屏幕上去。
一般来说在这个GLThread线程中是一个无限循环，根据收到的不同状态值，执行对应的操作，每执行一轮就会调用wait直到其他的状态被设置后notify唤醒，在循环执行。
在这里注意一下eglCreateWindowSurface函数中的native_window参数。它是一个Object对象，它的实现在com.google.android.gles_jni.EGLImpl.java（EGLImpl.java），先记住native_window可以传入的参数是SurfaceView、SurfaceHolder或者Surface，最终都转换成了Surface，Surface在Java层代表这一个窗口。
EGLSurface eglCreateWindowSurface(EGLDisplay display, EGLConfig config, Object native_window, int[] attrib_list) {
Surface sur = null;
if (native_window instanceof SurfaceView) {
SurfaceView surfaceView = (SurfaceView)native_window;
sur = surfaceView.getHolder().getSurface();
} else if (native_window instanceof SurfaceHolder) {
SurfaceHolder holder = (SurfaceHolder)native_window;
sur = holder.getSurface();
} else if (native_window instanceof Surface) {
// .......
}在native层使用EGL
在native层使用EGL创建EGL环境并且使用C/C++写OpenGL代码，思路就是结合前面两个Demo，在native层创建EGL环境和在Java层是类似的思路，只是有些API可能不一样，并且还用到了很多NDK的知识，
代码在这里https://github.com/qhyuan1992/OpenGL-ES/tree/master/NativeGLESViewWithEGL
核心部分的代码
void Renderer::requestInitEGL(ANativeWindow * pWindow) {
LOGI(1, "-------requestInitEGL");
pthread_mutex_lock(&mMutex);
mWindow = pWindow;
// mEnumRenderEvent表示事件
mEnumRenderEvent = RE_SURFACE_CHANGED;
LOGI(1, "-------mEnumRenderEvent=%d", mEnumRenderEvent);
pthread_mutex_unlock(&mMutex);
// 唤醒处于wait状态的线程，继续函数onRenderThreadRun的执行，onRenderThreadRun是线程的入口函数
pthread_cond_signal(&mCondVar);
}
// 每次需要绘制的时候调用，实际上会调用到
void Renderer::requestRenderFrame() {
pthread_mutex_lock(&mMutex);
mEnumRenderEvent = RE_DRAW_FRAME;
pthread_mutex_unlock(&mMutex);
pthread_cond_signal(&mCondVar);
}
void Renderer::requestDestroy() {
pthread_mutex_lock(&mMutex);
mEnumRenderEvent = RE_EXIT;
pthread_mutex_unlock(&mMutex);
pthread_cond_signal(&mCondVar);
}
void Renderer::onRenderThreadRun() {
mISRenderering = true;
while(mISRenderering) {
pthread_mutex_lock(&mMutex);
// 每完成一个事件就wait在这里直到有其他事件唤醒
pthread_cond_wait(&mCondVar, &mMutex);
LOGI(1, "-------this mEnumRenderEvent is %d", mEnumRenderEvent);
switch (mEnumRenderEvent) {
case RE_SURFACE_CHANGED:
LOGI(1, "-------case RE_SURFACE_CHANGED");
mEnumRenderEvent = RE_NONE;
pthread_mutex_unlock(&mMutex);
initEGL();
nativeSurfaceCreated();
nativeSurfaceChanged(mWidth, mHeight);
break;
case RE_DRAW_FRAME:
mEnumRenderEvent = RE_NONE;
pthread_mutex_unlock(&mMutex);
// draw
// 这个函数留给真实的GLES绘制操作。
nativeDraw();
eglSwapBuffers(mDisplay, mSurface);
break;
case RE_EXIT:
mEnumRenderEvent = RE_NONE;
pthread_mutex_unlock(&mMutex);
terminateDisplay();
mISRenderering = false;
break;
default:
mEnumRenderEvent = RE_NONE;
pthread_mutex_unlock(&mMutex);
}
}
}下面我也把native层创建EGL环境的部分列出来，显然和Java层是类似的。
void Renderer::initEGL() {
const EGLint attribs[] = {
EGL_SURFACE_TYPE, EGL_WINDOW_BIT,
EGL_BLUE_SIZE, 8,
EGL_GREEN_SIZE, 8,
EGL_RED_SIZE, 8,
EGL_NONE
};
EGLint width, height, format;
EGLint numConfigs;
EGLConfig config;
EGLSurface surface;
EGLContext context;
EGLDisplay display = eglGetDisplay(EGL_DEFAULT_DISPLAY);
eglInitialize(display, 0, 0);
eglChooseConfig(display, attribs, &config, 1, &numConfigs);
surface = eglCreateWindowSurface(display, config, mWindow, NULL);
EGLint attrs[]= {EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE};
context = eglCreateContext(display, config, NULL, attrs);
if (eglMakeCurrent(display, surface, surface, context) == EGL_FALSE) {
LOGI(1, "------EGL-FALSE");
return ;
}
eglQuerySurface(display, surface, EGL_WIDTH, &width);
eglQuerySurface(display, surface, EGL_HEIGHT, &height);
mDisplay = display;
mSurface = surface;
mContext = context;
mWidth = width;
mHeight = height;
LOGI(1, "width:%d, height:%d", mWidth, mHeight);
}在Java层继承自一个SurfaceView
public class MySurfaceView extends SurfaceView implements SurfaceHolder.Callback {
public MySurfaceView(Context context) {
super(context);
getHolder().addCallback(this);
}
@Override
public boolean onTouchEvent(MotionEvent event) {
nativeRequestRender();
return super.onTouchEvent(event);
}
@Override
public void surfaceCreated(SurfaceHolder surfaceHolder) {
setRender();
}
@Override
public void surfaceChanged(SurfaceHolder surfaceHolder, int i, int i1, int i2) {
nativeSurfaceChanged(surfaceHolder.getSurface());
}
@Override
public void surfaceDestroyed(SurfaceHolder surfaceHolder) {
nativeSurfaceDestroyed();
}
private void setRender() {
nativeStartRender();
}
private static native void nativeSurfaceChanged(Surface surface);
private static native void nativeSurfaceDestroyed();
private static native void nativeStartRender();
private static native void nativeRequestRender();
static {
System.loadLibrary("NativeWithEGL");
}
}转而在native层执行SurfaceHolder.Callback的回调，注意和前面的GLSurfaceView.Renderer的回调。
接下来在合适的时刻调用Renderer的request***函数，发出某种消息，比如执行requestRenderFrame函数，也就是发出了要绘制一帧的消息，那么在绘制线程中，就去执行OpenGL ES绘制操作代码。
ANativeWindow * mWindow;
Renderer * mRenderer;
extern "C" {
JNIEXPORT void JNICALL
Java_com_example_weiersyuan_nativeglesviewwithegl_MySurfaceView_nativeStartRender(JNIEnv *env, jclass type) {
mRenderer = new Renderer();
mRenderer->start();
}
JNIEXPORT void JNICALL
Java_com_example_weiersyuan_nativeglesviewwithegl_MySurfaceView_nativeSurfaceChanged(JNIEnv *env, jclass type, jobject surface) {
mWindow = ANativeWindow_fromSurface(env, surface);
// surfacechange时 发送SurfaceChanged消息，此时创建egl环境的消息
mRenderer->requestInitEGL(mWindow);
}
JNIEXPORT void JNICALL
Java_com_example_weiersyuan_nativeglesviewwithegl_MySurfaceView_nativeSurfaceDestroyed(JNIEnv *env, jclass type) {
mRenderer->requestDestroy();
ANativeWindow_release(mWindow);
delete mRenderer;
}
JNIEXPORT void JNICALL
Java_com_example_weiersyuan_nativeglesviewwithegl_MySurfaceView_nativeRequestRender(JNIEnv *env, jclass type){
mRenderer->requestRenderFrame();
}
}在Native层ANativeWindow对象代表一个窗口，看起来好像和Java层的Surface是对应着的，native层的ANativeWindow的指针是Java层的Surface对象的一个成员变量，这也是持久保存native层数据的常用方式，在NDK中有很多类似于ANativeWindow_fromSurface的函数，将Java层的独享转换为native层的对象，都是类似的方式。
Java代码自己写一个功能类似GLSurfaceView的类