implement GLES20 java bindings

These are just one to one bindings for the native OpenGL 2.0 APIs

meson.build

@@ -69,6 +69,7 @@ libtranslationlayer_so = shared_library('translation_layer_main', [
                                                                   	'src/api-impl-jni/views/android_view_ViewGroup.c',
                                                                   	'src/api-impl-jni/android_graphics_Bitmap.c',
                                                                   	'src/api-impl-jni/android_app_NativeActivity.c',
+                                                                  	'src/api-impl-jni/android_opengl_GLES20.c',
                                                                   ] + marshal_files,
                                                                   install: true,
                                                                   install_dir : get_option('libdir') / 'java/dex/android_translation_layer/natives',

src/api-impl-jni/android_opengl_GLES20.c

@@ -0,0 +1,236 @@
+#include <GLES2/gl2.h>
+#include <jni.h>
+#include <stdint.h>
+#include "defines.h"
+
+#include "generated_headers/android_opengl_GLES20.h"
+
+static void *get_nio_buffer(JNIEnv *env, jobject buffer, jarray *array_ref, jbyte **array) {
+    jclass class;
+    void *pointer;
+    int elementSizeShift, position;
+
+    if (!buffer) {
+        *array_ref = NULL;
+        return NULL;
+    }
+	class = _CLASS(buffer);
+	pointer = _PTR((*env)->GetLongField(env, buffer, _FIELD_ID(class, "address", "J")));
+	elementSizeShift = (*env)->GetIntField(env, buffer, _FIELD_ID(class, "_elementSizeShift", "I"));
+	position = (*env)->GetIntField(env, buffer, _FIELD_ID(class, "position", "I"));
+	if (pointer) {   // buffer is direct
+        *array_ref = NULL;
+		pointer += position << elementSizeShift;
+	} else {   // buffer is indirect
+		*array_ref = (*env)->CallObjectMethod(env, buffer, _METHOD(class, "array", "()Ljava/lang/Object;"));
+		pointer = *array = (*env)->GetPrimitiveArrayCritical(env, *array_ref, NULL);
+		jint offset = (*env)->CallIntMethod(env, buffer, _METHOD(class, "arrayOffset", "()I"));
+		pointer += (offset + position) << elementSizeShift;
+	}
+	return pointer;
+}
+
+static void release_nio_buffer(JNIEnv *env, jarray array_ref, jbyte *array) {
+	if (array_ref)
+		(*env)->ReleasePrimitiveArrayCritical(env, array_ref, array, 0);
+}
+
+JNIEXPORT jstring JNICALL Java_android_opengl_GLES20_glGetString(JNIEnv *env, jclass, jint name) {
+    const char* chars = (const char*) glGetString((GLenum) name);
+    return _JSTRING(chars);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGetIntegerv__I_3II(JNIEnv *env, jclass, jint pname, jintArray params_ref, jint offset) {
+    jint *params = (*env)->GetIntArrayElements(env, params_ref, NULL);
+    glGetIntegerv((GLenum)pname, params + offset);
+    (*env)->ReleaseIntArrayElements(env, params_ref, params, 0);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glEnableVertexAttribArray(JNIEnv *env, jclass, jint index) {
+    glEnableVertexAttribArray((GLuint)index);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glDisable(JNIEnv *env, jclass, jint cap) {
+    glDisable((GLenum)cap);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glEnable(JNIEnv *env, jclass, jint cap) {
+    glEnable((GLenum)cap);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glViewport(JNIEnv *env, jclass, jint x, jint y, jint width, jint height) {
+    glViewport((GLint)x, (GLint)y, (GLsizei)width, (GLsizei)height);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGenTextures__I_3II(JNIEnv *env, jclass, jint n, jintArray textures_ref, jint offset) {
+    jint *textures = (*env)->GetIntArrayElements(env, textures_ref, NULL);
+    glGenTextures((GLsizei)n, (GLuint *)textures + offset);
+    (*env)->ReleaseIntArrayElements(env, textures_ref, textures, 0);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glBindTexture(JNIEnv *env, jclass, jint target, jint texture) {
+    glBindTexture((GLenum)target, (GLuint)texture);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glTexImage2D(JNIEnv *env, jclass, jint target, jint level, jint internalformat, jint width, jint height, jint border, jint format, jint type, jobject pixels_buf) {
+    jarray array_ref;
+    jbyte *array;
+    GLvoid *pixels = get_nio_buffer(env, pixels_buf, &array_ref, &array);
+    glTexImage2D((GLenum)target, (GLint)level, (GLint)internalformat, (GLsizei)width, (GLsizei)height, (GLint)border, (GLenum)format, (GLenum)type, pixels);
+    release_nio_buffer(env, array_ref, array);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glTexSubImage2D(JNIEnv *env, jclass, jint target, jint level, jint xoffset, jint yoffset, jint width, jint height, jint format, jint type, jobject pixels_buf) {
+    jarray array_ref;
+    jbyte *array;
+    GLvoid *pixels = get_nio_buffer(env, pixels_buf, &array_ref, &array);
+    glTexSubImage2D((GLenum)target, (GLint)level, (GLint)xoffset, (GLint)yoffset, (GLsizei)width, (GLsizei)height, (GLenum)format, (GLenum)type, pixels);
+    release_nio_buffer(env, array_ref, array);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glTexParameterf(JNIEnv *env, jclass, jint target, jint pname, jfloat param) {
+    glTexParameterf((GLenum)target, (GLenum)pname, (GLfloat)param);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGenBuffers__I_3II(JNIEnv *env, jclass, jint n, jintArray buffers_ref, jint offset) {
+    jint *buffers = (*env)->GetIntArrayElements(env, buffers_ref, NULL);
+    glGenBuffers((GLsizei)n, (GLuint *)buffers + offset);
+    (*env)->ReleaseIntArrayElements(env, buffers_ref, buffers, 0);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glBindBuffer(JNIEnv *env, jclass, jint target, jint buffer) {
+    glBindBuffer((GLenum)target, (GLuint)buffer);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glBufferData(JNIEnv *env, jclass, jint target, jint size, jobject data_buf, jint usage) {
+    jarray array_ref;
+    jbyte *array;
+    GLvoid *data = get_nio_buffer(env, data_buf, &array_ref, &array);
+    glBufferData((GLenum)target, (GLsizeiptr)size, data, (GLenum)usage);
+    release_nio_buffer(env, array_ref, array);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glDisableVertexAttribArray(JNIEnv *env, jclass, jint index) {
+    glDisableVertexAttribArray((GLuint)index);
+}
+
+JNIEXPORT jint JNICALL Java_android_opengl_GLES20_glCreateShader(JNIEnv *env, jclass, jint type) {
+    return (jint)glCreateShader((GLenum)type);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glShaderSource(JNIEnv *env, jclass, jint shader, jstring string) {
+	const char* nativeString = (*env)->GetStringUTFChars(env, string, NULL);
+    const char* strings[] = {nativeString};
+    glShaderSource(shader, 1, strings, 0);
+	(*env)->ReleaseStringUTFChars(env, string, nativeString);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glCompileShader(JNIEnv *env, jclass, jint shader) {
+    glCompileShader((GLuint)shader);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGetShaderiv__II_3II(JNIEnv *env, jclass, jint shader, jint pname, jintArray params_ref, jint offset) {
+    jint *params = (*env)->GetIntArrayElements(env, params_ref, NULL);
+    glGetShaderiv((GLuint)shader, (GLenum)pname, params + offset);
+    (*env)->ReleaseIntArrayElements(env, params_ref, params, 0);
+}
+
+JNIEXPORT jint JNICALL Java_android_opengl_GLES20_glCreateProgram(JNIEnv *env, jclass) {
+    return (jint)glCreateProgram();
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glAttachShader(JNIEnv *env, jclass, jint program, jint shader) {
+    glAttachShader((GLuint)program, (GLuint)shader);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glBindAttribLocation(JNIEnv *env, jclass, jint program, jint index, jstring name) {
+	const char* nativeName = (*env)->GetStringUTFChars(env, name, NULL);
+    glBindAttribLocation((GLuint)program, (GLuint)index, nativeName);
+	(*env)->ReleaseStringUTFChars(env, name, nativeName);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glLinkProgram(JNIEnv *env, jclass, jint program) {
+    glLinkProgram((GLuint)program);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGetProgramiv__II_3II(JNIEnv *env, jclass, jint program, jint pname, jintArray params_ref, jint offset) {
+    jint *params = (*env)->GetIntArrayElements(env, params_ref, NULL);
+    glGetProgramiv((GLuint)program, (GLenum)pname, params + offset);
+    (*env)->ReleaseIntArrayElements(env, params_ref, params, 0);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGetActiveAttrib__III_3II_3II_3II_3BI(JNIEnv *env, jclass, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
+    jint *length = (*env)->GetIntArrayElements(env, length_ref, NULL);
+    jint *size = (*env)->GetIntArrayElements(env, size_ref, NULL);
+    jint *type = (*env)->GetIntArrayElements(env, type_ref, NULL);
+    jbyte *name = (*env)->GetByteArrayElements(env, name_ref, NULL);
+    glGetActiveAttrib((GLuint)program, (GLuint)index, (GLsizei)bufsize, (GLsizei *)length+lengthOffset, (GLint *)size+sizeOffset, (GLenum *)type+typeOffset, (char *)name+nameOffset);
+    (*env)->ReleaseByteArrayElements(env, name_ref, name, 0);
+    (*env)->ReleaseIntArrayElements(env, type_ref, type, 0);
+    (*env)->ReleaseIntArrayElements(env, size_ref, size, 0);
+    (*env)->ReleaseIntArrayElements(env, length_ref, length, 0);
+}
+
+JNIEXPORT jint JNICALL Java_android_opengl_GLES20_glGetAttribLocation(JNIEnv *env, jclass, jint program, jstring name) {
+	const char* nativeName = (*env)->GetStringUTFChars(env, name, NULL);
+    jint ret = glGetAttribLocation((GLuint)program, nativeName);
+	(*env)->ReleaseStringUTFChars(env, name, nativeName);
+    return ret;
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glGetActiveUniform__III_3II_3II_3II_3BI(JNIEnv *env, jclass, jint program, jint index, jint bufsize, jintArray length_ref, jint lengthOffset, jintArray size_ref, jint sizeOffset, jintArray type_ref, jint typeOffset, jbyteArray name_ref, jint nameOffset) {
+    jint *length = (*env)->GetIntArrayElements(env, length_ref, NULL);
+    jint *size = (*env)->GetIntArrayElements(env, size_ref, NULL);
+    jint *type = (*env)->GetIntArrayElements(env, type_ref, NULL);
+    jbyte *name = (*env)->GetByteArrayElements(env, name_ref, NULL);
+    glGetActiveUniform((GLuint)program, (GLuint)index, (GLsizei)bufsize, (GLsizei *)length+lengthOffset, (GLint *)size+sizeOffset, (GLenum *)type+typeOffset, (char *)name+nameOffset);
+    (*env)->ReleaseByteArrayElements(env, name_ref, name, 0);
+    (*env)->ReleaseIntArrayElements(env, type_ref, type, 0);
+    (*env)->ReleaseIntArrayElements(env, size_ref, size, 0);
+    (*env)->ReleaseIntArrayElements(env, length_ref, length, 0);
+}
+
+JNIEXPORT jint JNICALL Java_android_opengl_GLES20_glGetUniformLocation(JNIEnv *env, jclass, jint program, jstring name) {
+	const char* nativeName = (*env)->GetStringUTFChars(env, name, NULL);
+    jint ret = glGetUniformLocation((GLuint)program, nativeName);
+	(*env)->ReleaseStringUTFChars(env, name, nativeName);
+    return ret;
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glDeleteShader(JNIEnv *env, jclass, jint shader) {
+    glDeleteShader((GLuint)shader);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glUseProgram(JNIEnv *env, jclass, jint program) {
+    glUseProgram((GLuint)program);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glVertexAttribPointer(JNIEnv *env, jclass, jint indx, jint size, jint type, jboolean normalized, jint stride, jint offset) {
+    glVertexAttribPointer((GLuint)indx, (GLint)size, (GLenum)type, (GLboolean)normalized, (GLsizei)stride, (GLvoid *)(intptr_t)offset);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glUniformMatrix4fv__IIZ_3FI(JNIEnv *env, jclass, jint location, jint count, jboolean transpose, jfloatArray value_ref, jint offset) {
+    jfloat *value = (*env)->GetFloatArrayElements(env, value_ref, NULL);
+    glUniformMatrix4fv((GLint)location, (GLsizei)count, (GLboolean)transpose, (GLfloat *)value);
+    (*env)->ReleaseFloatArrayElements(env, value_ref, value, 0);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glUniform1i(JNIEnv *env, jclass, jint location, jint x) {
+    glUniform1i((GLint)location, (GLint)x);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glDrawArrays(JNIEnv *env, jclass, jint mode, jint first, jint count) {
+    glDrawArrays((GLenum)mode, (GLint)first, (GLsizei)count);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glClearColor(JNIEnv *env, jclass, jfloat red, jfloat green, jfloat blue, jfloat alpha) {
+    glClearColor((GLclampf)red, (GLclampf)green, (GLclampf)blue, (GLclampf)alpha);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glClear(JNIEnv *env, jclass, jint mask) {
+    glClear((GLbitfield)mask);
+}
+
+JNIEXPORT void JNICALL Java_android_opengl_GLES20_glBlendFunc(JNIEnv *env, jclass, jint sfactor, jint dfactor) {
+    glBlendFunc((GLenum)sfactor, (GLenum)dfactor);
+}

src/api-impl/meson.build

@@ -110,7 +110,9 @@ hax_jar = jar('hax', [
               	'android/net/Uri.java',
               	'android/opengl/EGLConfig.java',
               	'android/opengl/EGLObjectHandle.java',
+              	'android/opengl/GLES20.java',
               	'android/opengl/GLSurfaceView.java',
+              	'android/opengl/Matrix.java',
               	'android/os/AsyncTask.java',
               	'android/os/Binder.java',
               	'android/os/Build.java',