ShuriZma
/
flycast
mirror of https://github.com/flyinghead/flycast.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Android: disable EGL14 option, begin restructure

This commit is contained in:
Ender's Games 2018-08-07 11:34:37 -04:00
parent ce447e220c
commit acbfc2c5fd
2 changed files with 228 additions and 224 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

34
shell/android-studio/reicast/src/main/java/com/reicast/emulator/emu/GL2JNIView.java
View File

@ -183,29 +183,19 @@ public class GL2JNIView extends GLSurfaceView
// is interpreted as any 32-bit surface with alpha by SurfaceFlinger. // is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
if(translucent) this.getHolder().setFormat(PixelFormat.TRANSLUCENT); if(translucent) this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
if (prefs.getBoolean(Config.pref_egl14, false)) { // Setup the context factory for 2.0 rendering.
setEGLContextFactory(new GLCFactory14.ContextFactory()); // See ContextFactory class definition below
setEGLConfigChooser( setEGLContextFactory(new GLCFactory.ContextFactory());
translucent?
new GLCFactory14.ConfigChooser(8, 8, 8, 8, depth, stencil)
: new GLCFactory14.ConfigChooser(5, 6, 5, 0, depth, stencil)
);
GLES20.glEnable(GLES20.GL_DEPTH_TEST);
} else {
// Setup the context factory for 2.0 rendering.
// See ContextFactory class definition below
setEGLContextFactory(new GLCFactory.ContextFactory());
// We need to choose an EGLConfig that matches the format of // We need to choose an EGLConfig that matches the format of
// our surface exactly. This is going to be done in our // our surface exactly. This is going to be done in our
// custom config chooser. See ConfigChooser class definition // custom config chooser. See ConfigChooser class definition
// below. // below.
setEGLConfigChooser( setEGLConfigChooser(
translucent? translucent?
new GLCFactory.ConfigChooser(8, 8, 8, 8, depth, stencil) new GLCFactory.ConfigChooser(8, 8, 8, 8, depth, stencil)
: new GLCFactory.ConfigChooser(5, 6, 5, 0, depth, stencil) : new GLCFactory.ConfigChooser(5, 6, 5, 0, depth, stencil)
); );
}
// Set the renderer responsible for frame rendering // Set the renderer responsible for frame rendering
setRenderer(rend=new Renderer(this)); setRenderer(rend=new Renderer(this));

418
shell/android-studio/reicast/src/main/java/com/reicast/emulator/emu/GLCFactory14.java
View File

@ -2,17 +2,19 @@ package com.reicast.emulator.emu;
import android.annotation.TargetApi; import android.annotation.TargetApi;
import android.opengl.EGL14; import android.opengl.EGL14;
import android.opengl.EGLConfig;
import android.opengl.EGLContext;
import android.opengl.EGLDisplay;
import android.opengl.EGLExt; import android.opengl.EGLExt;
import android.opengl.GLSurfaceView; import android.opengl.EGLSurface;
import android.opengl.GLES20;
import android.os.Build; import android.os.Build;
import android.util.Log; import android.util.Log;
import android.view.Window;
import java.util.Locale; import java.util.Locale;
import javax.microedition.khronos.egl.EGL10; import javax.microedition.khronos.egl.EGL10;
import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.egl.EGLContext;
import javax.microedition.khronos.egl.EGLDisplay;
@TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2) @TargetApi(Build.VERSION_CODES.JELLY_BEAN_MR2)
public class GLCFactory14 { public class GLCFactory14 {
@ -25,33 +27,52 @@ public class GLCFactory14 {
private int EGL_DEPTH_ENCODING_NV = 0x30E2; private int EGL_DEPTH_ENCODING_NV = 0x30E2;
private int EGL_DEPTH_ENCODING_NONLINEAR_NV = 0x30E3; private int EGL_DEPTH_ENCODING_NONLINEAR_NV = 0x30E3;
public static class ContextFactory implements GLSurfaceView.EGLContextFactory private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
private void configureWindow() {
GLES20.glEnable(GLES20.GL_DEPTH_TEST);
}
public EGLDisplay getDisplay() {
EGLDisplay eglDisplay = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
if (eglDisplay == EGL14.EGL_NO_DISPLAY) {
throw new RuntimeException("eglGetDisplay failed");
}
int[] major = new int[1];
int[] minor = new int[1];
if (!EGL14.eglInitialize(eglDisplay, major, 0, minor, 0)) {
throw new RuntimeException("eglInitialize failed");
}
if (minor[0] < 4) {
throw new RuntimeException("EGL 1.4 required");
}
return eglDisplay;
}
public void terminate(EGLDisplay display) {
EGL14.eglTerminate(display);
}
public EGLContext createContext(EGLDisplay display, EGLConfig eglConfig)
{ {
private static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098; EGLContext context = EGL14.EGL_NO_CONTEXT;
for ( int clientVersion = 3; clientVersion >= 2; clientVersion-- ) {
int[] attrList = { EGL_CONTEXT_CLIENT_VERSION, clientVersion, EGL14.EGL_NONE };
public EGLContext createContext(EGL10 egl,EGLDisplay display,EGLConfig eglConfig) LOGI("Creating OpenGL ES " + clientVersion + " context");
{
EGLContext context = EGL10.EGL_NO_CONTEXT;
for ( int clientVersion = 3; clientVersion >= 2; clientVersion-- ) {
int[] attrList = { EGL_CONTEXT_CLIENT_VERSION, clientVersion, EGL14.EGL_NONE };
LOGI("Creating OpenGL ES " + clientVersion + " context"); context = EGL14.eglCreateContext(display, eglConfig, EGL14.EGL_NO_CONTEXT, attrList, 0);
if (context != EGL14.EGL_NO_CONTEXT) {
checkEglError("Before eglCreateContext",egl); break;
context = egl.eglCreateContext(display,eglConfig,EGL10.EGL_NO_CONTEXT,attrList);
checkEglError("After eglCreateContext",egl);
if (context != EGL10.EGL_NO_CONTEXT) {
break;
}
} }
return(context);
} }
return(context);
}
public void destroyContext(EGL10 egl,EGLDisplay display,EGLContext context) public void destroyContext(EGLDisplay display, EGLContext context) {
{ EGL14.eglDestroyContext(display, context);
LOGI("Destroying OpenGL ES X context");
egl.eglDestroyContext(display,context);
}
} }
private static void checkEglError(String prompt,EGL10 egl) private static void checkEglError(String prompt,EGL10 egl)
@ -62,200 +83,193 @@ public class GLCFactory14 {
LOGE(String.format(Locale.getDefault(), "%s: EGL error: 0x%x",prompt,error)); LOGE(String.format(Locale.getDefault(), "%s: EGL error: 0x%x",prompt,error));
} }
public static class ConfigChooser implements GLSurfaceView.EGLConfigChooser // Subclasses can adjust these values:
{ protected int mRedSize;
// Subclasses can adjust these values: protected int mGreenSize;
protected int mRedSize; protected int mBlueSize;
protected int mGreenSize; protected int mAlphaSize;
protected int mBlueSize; protected int mDepthSize;
protected int mAlphaSize; protected int mStencilSize;
protected int mDepthSize; private int[] mValue = new int[1];
protected int mStencilSize;
private int[] mValue = new int[1];
public ConfigChooser(int r,int g,int b,int a,int depth,int stencil) public EGLConfig chooseConfig(EGLDisplay display) {
{ mValue = new int[1];
mRedSize = r;
mGreenSize = g; int glAPIToTry = EGLExt.EGL_OPENGL_ES3_BIT_KHR;
mBlueSize = b; int[] configSpec = null;
mAlphaSize = a;
mDepthSize = depth; do {
mStencilSize = stencil; EGL14.eglBindAPI(glAPIToTry);
int renderableType;
if (glAPIToTry == EGLExt.EGL_OPENGL_ES3_BIT_KHR) {
renderableType = EGLExt.EGL_OPENGL_ES3_BIT_KHR;
// If this API does not work, try ES2 next.
glAPIToTry = EGL14.EGL_OPENGL_ES2_BIT;
} else {
renderableType = EGL14.EGL_OPENGL_ES2_BIT;
// If this API does not work, is a potato.
glAPIToTry = EGL10.EGL_NONE;
}
// This EGL config specification is used to specify 3.0 rendering.
// We use a minimum size of 8 bits for red/green/blue, but will
// perform actual matching in chooseConfig() below.
configSpec = new int[] {
EGL14.EGL_RED_SIZE, 8,
EGL14.EGL_GREEN_SIZE, 8,
EGL14.EGL_BLUE_SIZE, 8,
EGL14.EGL_RENDERABLE_TYPE, renderableType,
EGL14.EGL_DEPTH_SIZE, 16,
EGL14.EGL_NONE
};
if (!EGL14.eglChooseConfig(display, configSpec, 0,null, 0, 0, mValue, 0)) {
configSpec[9] = 16;
if (!EGL14.eglChooseConfig(display, configSpec, 0,null, 0, 0, mValue, 0)) {
throw new IllegalArgumentException("Could not get context count");
}
}
} while (glAPIToTry != EGL10.EGL_NONE && mValue[0]<=0);
if (mValue[0]<=0) {
throw new IllegalArgumentException("No configs match configSpec");
} }
public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) { // Get all matching configurations.
mValue = new int[1]; EGLConfig[] configs = new EGLConfig[mValue[0]];
if (GL2JNIView.DEBUG)
LOGW(String.format(Locale.getDefault(), "%d configurations", configs.length));
if (!EGL14.eglChooseConfig(display, configSpec, 0, configs,0, mValue[0], mValue, 0)) {
throw new IllegalArgumentException("Could not get config data");
}
int glAPIToTry = EGLExt.EGL_OPENGL_ES3_BIT_KHR; for (int i = 0; i < configs.length; ++i) {
int[] configSpec = null; EGLConfig config = configs[i];
int d = findConfigAttrib(display, config, EGL14.EGL_DEPTH_SIZE, 0);
int s = findConfigAttrib(display, config, EGL14.EGL_STENCIL_SIZE, 0);
do { // We need at least mDepthSize and mStencilSize bits
EGL14.eglBindAPI(glAPIToTry); if (d >= mDepthSize || s >= mStencilSize) {
// We want an *exact* match for red/green/blue/alpha
int r = findConfigAttrib(display, config, EGL14.EGL_RED_SIZE, 0);
int g = findConfigAttrib(display, config, EGL14.EGL_GREEN_SIZE, 0);
int b = findConfigAttrib(display, config, EGL14.EGL_BLUE_SIZE, 0);
int a = findConfigAttrib(display, config, EGL14.EGL_ALPHA_SIZE, 0);
int renderableType; if (r == mRedSize && g == mGreenSize && b == mBlueSize
if (glAPIToTry == EGLExt.EGL_OPENGL_ES3_BIT_KHR) { && a == mAlphaSize)
renderableType = EGLExt.EGL_OPENGL_ES3_BIT_KHR; if (GL2JNIView.DEBUG) {
// If this API does not work, try ES2 next. LOGW(String.format("Configuration %d:", i));
glAPIToTry = EGL14.EGL_OPENGL_ES2_BIT; printConfig(display, configs[i]);
} else {
renderableType = EGL14.EGL_OPENGL_ES2_BIT;
// If this API does not work, is a potato.
glAPIToTry = EGL10.EGL_NONE;
}
// This EGL config specification is used to specify 2.0 rendering.
// We use a minimum size of 4 bits for red/green/blue, but will
// perform actual matching in chooseConfig() below.
configSpec = new int[] {
EGL14.EGL_RED_SIZE, 4,
EGL14.EGL_GREEN_SIZE, 4,
EGL14.EGL_BLUE_SIZE, 4,
EGL14.EGL_RENDERABLE_TYPE, renderableType,
EGL14.EGL_DEPTH_SIZE, 16,
EGL14.EGL_NONE
};
if (!egl.eglChooseConfig(display, configSpec, null, 0, mValue)) {
configSpec[9] = 16;
if (!egl.eglChooseConfig(display, configSpec, null, 0, mValue)) {
throw new IllegalArgumentException("Could not get context count");
} }
} return config;
} while (glAPIToTry != EGL10.EGL_NONE && mValue[0]<=0);
if (mValue[0]<=0) {
throw new IllegalArgumentException("No configs match configSpec");
} }
// Get all matching configurations.
EGLConfig[] configs = new EGLConfig[mValue[0]];
if (GL2JNIView.DEBUG)
LOGW(String.format(Locale.getDefault(), "%d configurations", configs.length));
if (!egl.eglChooseConfig(display, configSpec, configs, mValue[0], mValue)) {
throw new IllegalArgumentException("Could not get config data");
}
for (int i = 0; i < configs.length; ++i) {
EGLConfig config = configs[i];
int d = findConfigAttrib(egl, display, config,
EGL14.EGL_DEPTH_SIZE, 0);
int s = findConfigAttrib(egl, display, config,
EGL14.EGL_STENCIL_SIZE, 0);
// We need at least mDepthSize and mStencilSize bits
if (d >= mDepthSize || s >= mStencilSize) {
// We want an *exact* match for red/green/blue/alpha
int r = findConfigAttrib(egl, display, config,
EGL14.EGL_RED_SIZE, 0);
int g = findConfigAttrib(egl, display, config,
EGL14.EGL_GREEN_SIZE, 0);
int b = findConfigAttrib(egl, display, config,
EGL14.EGL_BLUE_SIZE, 0);
int a = findConfigAttrib(egl, display, config,
EGL14.EGL_ALPHA_SIZE, 0);
if (r == mRedSize && g == mGreenSize && b == mBlueSize
&& a == mAlphaSize)
if (GL2JNIView.DEBUG) {
LOGW(String.format("Configuration %d:", i));
printConfig(egl, display, configs[i]);
}
return config;
}
}
throw new IllegalArgumentException("Could not find suitable EGL config");
} }
private int findConfigAttrib(EGL10 egl,EGLDisplay display,EGLConfig config,int attribute,int defaultValue) throw new IllegalArgumentException("Could not find suitable EGL config");
{ }
return(egl.eglGetConfigAttrib(display,config,attribute,mValue)? mValue[0] : defaultValue);
}
private void printConfig(EGL10 egl,EGLDisplay display,EGLConfig config) private int findConfigAttrib(EGLDisplay display, EGLConfig config, int defaultValue, int attribute) {
{ int[] value = new int[1];
final int[] attributes = if (EGL14.eglGetConfigAttrib(display, config, attribute, value, 0)) {
return value[0];
}
return defaultValue;
}
private void printConfig(EGLDisplay display, EGLConfig config)
{
final int[] attributes =
{ {
EGL14.EGL_BUFFER_SIZE, EGL14.EGL_BUFFER_SIZE,
EGL14.EGL_ALPHA_SIZE, EGL14.EGL_ALPHA_SIZE,
EGL14.EGL_BLUE_SIZE, EGL14.EGL_BLUE_SIZE,
EGL14.EGL_GREEN_SIZE, EGL14.EGL_GREEN_SIZE,
EGL14.EGL_RED_SIZE, EGL14.EGL_RED_SIZE,
EGL14.EGL_DEPTH_SIZE, EGL14.EGL_DEPTH_SIZE,
EGL14.EGL_STENCIL_SIZE, EGL14.EGL_STENCIL_SIZE,
EGL14.EGL_CONFIG_CAVEAT, EGL14.EGL_CONFIG_CAVEAT,
EGL14.EGL_CONFIG_ID, EGL14.EGL_CONFIG_ID,
EGL14.EGL_LEVEL, EGL14.EGL_LEVEL,
EGL14.EGL_MAX_PBUFFER_HEIGHT, EGL14.EGL_MAX_PBUFFER_HEIGHT,
EGL14.EGL_MAX_PBUFFER_PIXELS, EGL14.EGL_MAX_PBUFFER_PIXELS,
EGL14.EGL_MAX_PBUFFER_WIDTH, EGL14.EGL_MAX_PBUFFER_WIDTH,
EGL14.EGL_NATIVE_RENDERABLE, EGL14.EGL_NATIVE_RENDERABLE,
EGL14.EGL_NATIVE_VISUAL_ID, EGL14.EGL_NATIVE_VISUAL_ID,
EGL14.EGL_NATIVE_VISUAL_TYPE, EGL14.EGL_NATIVE_VISUAL_TYPE,
0x3030, // EGL14.EGL_PRESERVED_RESOURCES, 0x3030, // EGL14.EGL_PRESERVED_RESOURCES,
EGL14.EGL_SAMPLES, EGL14.EGL_SAMPLES,
EGL14.EGL_SAMPLE_BUFFERS, EGL14.EGL_SAMPLE_BUFFERS,
EGL14.EGL_SURFACE_TYPE, EGL14.EGL_SURFACE_TYPE,
EGL14.EGL_TRANSPARENT_TYPE, EGL14.EGL_TRANSPARENT_TYPE,
EGL14.EGL_TRANSPARENT_RED_VALUE, EGL14.EGL_TRANSPARENT_RED_VALUE,
EGL14.EGL_TRANSPARENT_GREEN_VALUE, EGL14.EGL_TRANSPARENT_GREEN_VALUE,
EGL14.EGL_TRANSPARENT_BLUE_VALUE, EGL14.EGL_TRANSPARENT_BLUE_VALUE,
EGL14.EGL_BIND_TO_TEXTURE_RGB, EGL14.EGL_BIND_TO_TEXTURE_RGB,
EGL14.EGL_BIND_TO_TEXTURE_RGBA, EGL14.EGL_BIND_TO_TEXTURE_RGBA,
EGL14.EGL_MIN_SWAP_INTERVAL, EGL14.EGL_MIN_SWAP_INTERVAL,
EGL14.EGL_MAX_SWAP_INTERVAL, EGL14.EGL_MAX_SWAP_INTERVAL,
EGL14.EGL_LUMINANCE_SIZE, EGL14.EGL_LUMINANCE_SIZE,
EGL14.EGL_ALPHA_MASK_SIZE, EGL14.EGL_ALPHA_MASK_SIZE,
EGL14.EGL_COLOR_BUFFER_TYPE, EGL14.EGL_COLOR_BUFFER_TYPE,
EGL14.EGL_RENDERABLE_TYPE, EGL14.EGL_RENDERABLE_TYPE,
EGL14.EGL_CONFORMANT EGL14.EGL_CONFORMANT
}; };
final String[] names = final String[] names =
{ {
"EGL_BUFFER_SIZE", "EGL_BUFFER_SIZE",
"EGL_ALPHA_SIZE", "EGL_ALPHA_SIZE",
"EGL_BLUE_SIZE", "EGL_BLUE_SIZE",
"EGL_GREEN_SIZE", "EGL_GREEN_SIZE",
"EGL_RED_SIZE", "EGL_RED_SIZE",
"EGL_DEPTH_SIZE", "EGL_DEPTH_SIZE",
"EGL_STENCIL_SIZE", "EGL_STENCIL_SIZE",
"EGL_CONFIG_CAVEAT", "EGL_CONFIG_CAVEAT",
"EGL_CONFIG_ID", "EGL_CONFIG_ID",
"EGL_LEVEL", "EGL_LEVEL",
"EGL_MAX_PBUFFER_HEIGHT", "EGL_MAX_PBUFFER_HEIGHT",
"EGL_MAX_PBUFFER_PIXELS", "EGL_MAX_PBUFFER_PIXELS",
"EGL_MAX_PBUFFER_WIDTH", "EGL_MAX_PBUFFER_WIDTH",
"EGL_NATIVE_RENDERABLE", "EGL_NATIVE_RENDERABLE",
"EGL_NATIVE_VISUAL_ID", "EGL_NATIVE_VISUAL_ID",
"EGL_NATIVE_VISUAL_TYPE", "EGL_NATIVE_VISUAL_TYPE",
"EGL_PRESERVED_RESOURCES", "EGL_PRESERVED_RESOURCES",
"EGL_SAMPLES", "EGL_SAMPLES",
"EGL_SAMPLE_BUFFERS", "EGL_SAMPLE_BUFFERS",
"EGL_SURFACE_TYPE", "EGL_SURFACE_TYPE",
"EGL_TRANSPARENT_TYPE", "EGL_TRANSPARENT_TYPE",
"EGL_TRANSPARENT_RED_VALUE", "EGL_TRANSPARENT_RED_VALUE",
"EGL_TRANSPARENT_GREEN_VALUE", "EGL_TRANSPARENT_GREEN_VALUE",
"EGL_TRANSPARENT_BLUE_VALUE", "EGL_TRANSPARENT_BLUE_VALUE",
"EGL_BIND_TO_TEXTURE_RGB", "EGL_BIND_TO_TEXTURE_RGB",
"EGL_BIND_TO_TEXTURE_RGBA", "EGL_BIND_TO_TEXTURE_RGBA",
"EGL_MIN_SWAP_INTERVAL", "EGL_MIN_SWAP_INTERVAL",
"EGL_MAX_SWAP_INTERVAL", "EGL_MAX_SWAP_INTERVAL",
"EGL_LUMINANCE_SIZE", "EGL_LUMINANCE_SIZE",
"EGL_ALPHA_MASK_SIZE", "EGL_ALPHA_MASK_SIZE",
"EGL_COLOR_BUFFER_TYPE", "EGL_COLOR_BUFFER_TYPE",
"EGL_RENDERABLE_TYPE", "EGL_RENDERABLE_TYPE",
"EGL_CONFORMANT" "EGL_CONFORMANT"
}; };
int[] value = new int[1]; int[] value = new int[1];
for(int i=0 ; i<attributes.length ; i++) for(int i=0 ; i<attributes.length ; i++)
if(egl.eglGetConfigAttrib(display,config,attributes[i],value)) if(EGL14.eglGetConfigAttrib(display, config, attributes[i], value,0))
LOGI(String.format(Locale.getDefault(), " %s: %d\n",names[i],value[0])); LOGI(String.format(Locale.getDefault(), " %s: %d\n",names[i],value[0]));
else else
while(egl.eglGetError()!=EGL14.EGL_SUCCESS); while(EGL14.eglGetError() != EGL14.EGL_SUCCESS);
} }
public EGLSurface createWindowSurface(EGLDisplay display, EGLConfig config, Window window) {
EGLSurface eglSurface = EGL14.eglCreateWindowSurface(display, config, window, null, 0);
return eglSurface;
}
public void destroySurface(EGLDisplay display, EGLSurface window) {
EGL14.eglDestroySurface(display, window);
} }
} }