Building OpenGLES environment based on GlsurfaceView

By Surface

Simple customizing GLSurfaceView.

package com.byteflow.app;

import android.content.Context;
import android.opengl.GLSurfaceView;
import android.util.AttributeSet;
import android.util.Log;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

public class MyGLSurfaceView extends GLSurfaceView {< br> private static final String TAG = “MyGLSurfaceView”;

public static final int IMAGE_FORMAT_RGBA = 0x01;
public static final int IMAGE_FORMAT_NV21 = 0x02;
public static final int IMAGE_FORMAT_NV12 = 0x03;< br> public static final int IMAGE_FORMAT_I420 = 0x04;

private MyGLRender mGLRender;
private MyNativeRender mNativeRender;

public MyGLSurfaceView(Context context) {
this(context, null );
}

public MyGLSurfaceView(Context context, AttributeSet attrs) {
super(context, attrs);
this.setEGLContextClientVersion(3);
mNativeRender = new MyNativeRender ();
mGLRender = new MyGLRender(mNativeRen der);
setRenderer(mGLRender);
setRenderMode(RENDERMODE_CONTINUOUSLY);
}

public MyNativeRender getNativeRender() {
return mNativeRender;
}

public static class MyGLRender implements GLSurfaceView.Renderer {
private MyNativeRender mNativeRender;

MyGLRender(MyNativeRender myNativeRender) {
mNativeRender = myNativeRender;
}

@Override
public void onSurfaceCreated(GL10 gl, EGLConfig config) {
Log.d(TAG, “onSurfaceCreated() called with: gl = [” + gl + “], config = [” + config + ” ]”);
mNativeRender.native_OnSurfaceCreated();

}

@Override
public void onSurfaceChanged(GL10 gl, int width, int height) {
Log.d(TAG, “onSurfaceChanged() called with: gl = [” + gl + “], width = [” + width + “], height = [” + height + “]”);
mNativeRender. native_OnSurfaceChanged(width, height);

}

@Override
public void onDrawFrame(GL10 gl) {
Log.d(TAG, “onDrawFrame() called with : gl = [” + gl + “]” );
mNativeRender.native_OnDrawFrame();

}
}
}

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17< br>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< br>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< br>JNI class.

package com.byteflow.app;

public class MyNativeRender {
static {
System.loadLibrary(“native-render”);
}

public native void native_OnInit();

public native void native_OnUnInit();

public native void native_SetImageData(int format, int width, int height, byte[] bytes);

public native void native_OnSurfaceCreated();

public native void native_OnSurfaceChanged(int width, int height);

public native void native_OnDrawFrame();
}
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
The Native layer simply implements JNI.

//
// Created by ByteFlow on 2019/7/9.
//
#include “util/LogUtil.h”
#include
#include “jni.h”

#define NATIVE_RENDER_CLASS_NAME “com/byteflow/app/MyNativeRender”

#ifdef __cplusplus
extern “C” {
#endif
/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_OnInit
* Signature: ()V
*/
JNIEXPORT void JNICALL native_OnInit(JNIEnv *env, jobject instance )
{
MyGLRenderContext::GetInstance();

}

/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_OnUnInit
* Signature: ()V
*/
JNIEXPORT void JNICALL native_OnUnInit(JNIEnv *env, jobject instance)
{
MyGLRenderContext::DestroyInstance();
}

/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_SetImageData
* Signature: (III[B)V
*/
JNIEXPORT void JNICALL native_SetImageData
(JNIEnv *env, jobject instance , jint format, jint width, jint height, jbyteArray imageData)
{
int len ​​= env->GetArrayLength (imageData);
uint8_t* buf = new uint8_t[len];
env->GetByteArrayRegion(imageData, 0, len, reinterpret_cast(buf)) ;
MyGLRenderContext::GetInstance()->SetImageData(format, width, height, buf);
delete[] buf;
env->DeleteLocalRef(imageData);
}

/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_OnSurfaceCreated
* Signature: ()V
*/
JNIEXPORT void JNICALL native_OnSurfaceCreated(JNIEnv *env, jobject instance)
{
MyGLRenderContext::GetInstance()->OnSurfaceCreated();
}

/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_OnSurfaceChanged
* Signature: (II)V
*/
JNIEXPORT void JNICALL native_OnSurfaceChanged
(JNIEnv *env, jobject instance, jint width, jint height)
{
MyGLRenderContext::GetInstance()->OnSurfaceChanged( width, height);

}

/*
* Class: com_byteflow_app_MyNativeRender
* Method: native_OnDrawFrame
* Signature: ()V< br> */
JNIEXPORT void JNICALL native_OnDrawFrame(JNIEnv *env, jobject instance)
{
MyGLRenderContext::GetInstance()->OnDrawFrame();

}

#ifdef __cplusplus
}
#endif

static JNINativeMethod g_RenderMethods[] = {
{“native_OnInit”, “()V”, (void *)(native_OnInit) },
{“native_OnUnInit”, “()V”, (void *)(native_OnUnInit)},
{“native_SetImageData”, “(III[B)V”, (void *)(native_SetImageData)} ,
{“native_OnSurfaceCreated”, “()V”, (void *)(native_OnSurfaceCreated)},
{“native_OnSurfaceChanged”, “(II)V”, (void *)(native_OnSurfaceChanged)},
{“native_OnDrawFrame”, “()V”, (void *)(native_OnDrawFrame)},
};

static int RegisterNativeMethods(JNIEnv *env, const char *className, JNINativeMethod *methods, int methodNum)
{
LOGCATE(“RegisterNativeMethods”);
jclass clazz = env->FindClass(className);
if (clazz == NULL)
{
LOGCATE( “RegisterNativeMethods fail. clazz == NULL”);
return JNI_FALSE;
}
if (env->RegisterNative s(clazz, methods, methodNum) <0)
{
LOGCATE(“RegisterNativeMethods fail”);
return JNI_FALSE;
}
return JNI_TRUE;
}

static void UnregisterNativeMethods(JNIEnv *env, const char *className)
{
LOGCATE(“UnregisterNativeMethods”);
jclass clazz = env->FindClass(className);
if (clazz == NULL)
{
LOGCATE(“UnregisterNativeMethods fail. clazz == NULL”);
return;
}
if (env != NULL)
{
env->UnregisterNatives(clazz);
}
}

// call this func when loading lib
extern “C” jint JNI_OnLoad(JavaVM *jvm, void *p)< br>{
LOGCATE(“===== JNI_OnLoad =====”);
jint jniRet = JNI_ERR;
JNIEnv *env = NULL;
if (jvm->GetEnv( (void **) (&env), JNI_VERSION_1_6) != JNI_OK)
{
return jniRet;
}

jint regRet = RegisterNativeMethods(env, NATIVE_RENDER_CLASS_NAME, g_RenderMethods,
sizeof(g_RenderMethods) /
sizeof(g_RenderMethods[0]));
if (regRet != JNI_TRUE)
{
return JNI_ERR;
}

retu rn JNI_VERSION_1_6;
}

extern “C” void JNI_OnUnload(JavaVM *jvm, void *p)
{
JNIEnv *env = NULL;
if (jvm-> GetEnv((void **) (&env), JNI_VERSION_1_6) != JNI_OK)
{
return;
}

UnregisterNativeMethods(env, NATIVE_RENDER_CLASS_NAME);
}

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
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119< br>120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144< br>145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
The Render wrapper class of the Native layer, and other Samples are implemented in this class.

//
// Created by ByteFlow on 2019/7/9.
//

#include
#include “MyGLRenderContext .h”
#include “LogUtil.h”

MyGLRenderContext* MyGLRenderContext::m_pContext = nullptr;

MyGLRenderContext::MyGLRenderContext()
{

}

MyGLRenderContext::~MyGLRenderContext()
{

}

void MyGLRenderContext::SetImageData(int format, int width, int height, uint8_t *pData)
{
LOGCATE(“MyGLRenderContext::SetImageData format=%d, width=%d, height=%d, pData=%p”, format, width, height, pData);
NativeImage nativeImage;
nativeImage.format = format;
nativeImage.width = width;
nativeImage.height = height;
nativeImage.ppPlane[0] = pData;

< p> switch (format)
{
case IMAGE_FORMAT_NV12:
case IMAGE_FORMAT_NV21:
nativeImage.ppPlane[1] = nativeImage.ppPlane[0] + width * height;
break;
case IMAGE_FORMAT_I420:
nativeImage.ppPlane[1] = nativeImage.ppPlane[0] + width * height;
nativeImage.p pPlane[2] = nativeImage.ppPlane[1] + width * height / 4;
break;
default:
break;
}

//m_TextureMapSample->LoadImage (&nativeImage);

}

void MyGLRenderContext::OnSurfaceCreated()
{
LOGCATE(“MyGLRenderContext::OnSurfaceCreated”);
glClearColor(1.0f ,1.0f,0.5f, 1.0f);
m_Sample.Init();
}

void MyGLRenderContext::OnSurfaceChanged(int width, int height)
{
LOGCATE(“MyGLRenderContext::OnSurfaceChanged [w, h] = [%d, %d]”, width, height);
glViewport(0, 0, width, height);
}

< p>void MyGLRenderContext::OnDrawFrame()
{
LOGCATE(“MyGLRenderContext::OnDrawFrame”);
glClear(GL_DEPTH_BUFFER_BIT | GL_COLOR_BUFFER_BIT);

m_Sample.Draw();< /p>

}

MyGLRenderContext *MyGLRenderContext::GetInstance()
{
LOGCATE(“MyGLRenderContext::GetInstance”);
if (m_pContext == nullptr)
{
m_pContext = new MyGLRenderContext();
}
return m_pContext;
}

void MyGLRenderContext::DestroyInstance( )
{
LOGCATE(“MyGLRenderContext::DestroyInstance”);
if (m_pContext)
{
delete m_pContext;
m_pContext = nullptr;
}

}

, , , ,

WordPress database error: [Table 'yf99682.wp_s6mz6tyggq_comments' doesn't exist]
SELECT SQL_CALC_FOUND_ROWS wp_s6mz6tyggq_comments.comment_ID FROM wp_s6mz6tyggq_comments WHERE ( comment_approved = '1' ) AND comment_post_ID = 1536 ORDER BY wp_s6mz6tyggq_comments.comment_date_gmt ASC, wp_s6mz6tyggq_comments.comment_ID ASC

Leave a Comment

Your email address will not be published.