/** Some initialization of the OpenGL stuff (that I don't understand...) */
protected void init() {
// Much of this code is from GLSurfaceView in the Google API Demos.
// I encourage those interested to look there for documentation.
egl = (EGL10) EGLContext.getEGL();
dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
egl.eglInitialize(dpy, version);
int[] configSpec = {
EGL10.EGL_RED_SIZE, 5,
EGL10.EGL_GREEN_SIZE, 6,
EGL10.EGL_BLUE_SIZE, 5,
EGL10.EGL_DEPTH_SIZE, 8,
EGL10.EGL_NONE
};
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
egl.eglChooseConfig(dpy, configSpec, configs, 1, num_config);
EGLConfig config = configs[0];
eglContext = egl.eglCreateContext(dpy, config, EGL10.EGL_NO_CONTEXT, null);
surface = egl.eglCreateWindowSurface(dpy, config, sHolder, null);
egl.eglMakeCurrent(dpy, surface, surface, eglContext);
gl = (GL10) eglContext.getGL();
// Load the buffer and stuff
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.glClearDepthf(1.0f);
gl.glVertexPointer(3, GL10.GL_FLOAT, 0, cubeBuff);
gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);
gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, texBuff);
gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);
gl.glEnable(GL10.GL_TEXTURE_2D);
// Resize... whatever?
gl.glMatrixMode(GL10.GL_PROJECTION);
gl.glLoadIdentity();
gl.glViewport(0, 0, width, height);
GLU.gluPerspective(gl, 45.0f, ((float) width) / height, 1f, 100f);
gl.glMatrixMode(GL10.GL_MODELVIEW);
gl.glLoadIdentity();
GLU.gluLookAt(gl, 0, 0, 5.5f, 0, 0, 0, 0, 1, 0);
gl.glNormal3f(0, 0, 1);
}
private static void initEGL() {
if (sEGL != null) {
return;
}
sEGL = (EGL10) EGLContext.getEGL();
sEGLDisplay = sEGL.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (sEGLDisplay == EGL10.EGL_NO_DISPLAY) {
Log.w(LOGTAG, "can't get EGL display!");
return;
}
// while calling eglInitialize here should not be necessary as it was already called
// by the EGLPreloadingThread, it really doesn't cost much to call it again here,
// and makes this code easier to think about: EGLPreloadingThread is only a
// preloading optimization, not something we rely on for anything else.
//
// Also note that while calling eglInitialize isn't necessary on Android 4.x
// (at least Android's HardwareRenderer does it for us already), it is necessary
// on Android 2.x.
int[] returnedVersion = new int[2];
if (!sEGL.eglInitialize(sEGLDisplay, returnedVersion)) {
Log.w(LOGTAG, "eglInitialize failed");
return;
}
sEGLConfig = chooseConfig();
}
protected boolean checkGL20() {
EGL10 egl = (EGL10) EGLContext.getEGL();
EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
egl.eglInitialize(display, version);
int EGL_OPENGL_ES2_BIT = 4;
int[] configAttribs = {
EGL10.EGL_RED_SIZE,
4,
EGL10.EGL_GREEN_SIZE,
4,
EGL10.EGL_BLUE_SIZE,
4,
EGL10.EGL_RENDERABLE_TYPE,
EGL_OPENGL_ES2_BIT,
EGL10.EGL_NONE
};
EGLConfig[] configs = new EGLConfig[10];
int[] num_config = new int[1];
egl.eglChooseConfig(display, configAttribs, configs, 10, num_config);
egl.eglTerminate(display);
return num_config[0] > 0;
}
/** Initialize EGL for a given configuration spec. */
public void start(SurfaceTexture mSurface) {
if (LOG_EGL) {
Log.d("EglHelper", "start() tid=" + Thread.currentThread().getId());
}
/*
* Get an EGL instance
*/
mEgl = (EGL10) EGLContext.getEGL();
/*
* Get to the default display.
*/
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
throw new RuntimeException("eglGetDisplay failed");
}
/*
* We can now initialize EGL for that display
*/
int[] version = new int[2];
if (!mEgl.eglInitialize(mEglDisplay, version)) {
throw new RuntimeException("eglInitialize failed");
}
mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
if (mEglConfig == null) {
throw new RuntimeException("eglConfig not initialized");
}
/*
* Create an EGL context. We want to do this as rarely as we can, because an
* EGL context is a somewhat heavy object.
*/
mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
mEglContext = null;
throwEglException("createContext");
}
if (LOG_EGL) {
Log.d(
"EglHelper", "createContext " + mEglContext + " tid=" + Thread.currentThread().getId());
}
mEglSurface = mEgl.eglCreateWindowSurface(mEglDisplay, mEglConfig, mSurface, null);
if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
int error = mEgl.eglGetError();
if (error == EGL10.EGL_BAD_NATIVE_WINDOW) {
Log.e("EglHelper", "createWindowSurface returned EGL_BAD_NATIVE_WINDOW.");
}
throw new RuntimeException(
"createWindowSurface failed " + GLUtils.getEGLErrorString(error));
}
if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
throw new RuntimeException(
"eglMakeCurrent failed " + GLUtils.getEGLErrorString(mEgl.eglGetError()));
}
}
@Override
public void surfaceCreated(SurfaceHolder holder) {
Log.d(TAG, "surfaceCreated");
// Lots of stunningly tedious EGL setup. All we want is a 565 surface.
egl = (EGL10) EGLContext.getEGL();
display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
if (!egl.eglInitialize(display, version)) {
throw new RuntimeException("eglInitialize failed");
}
/*
int[] attrib_list = new int[] {
EGL10.EGL_RED_SIZE, 5,
EGL10.EGL_GREEN_SIZE, 6,
EGL10.EGL_BLUE_SIZE, 5,
EGL10.EGL_ALPHA_SIZE, 0,
EGL10.EGL_DEPTH_SIZE, 0,
EGL10.EGL_NONE
};
egl.eglGetConfigs(display, configs, config_size, num_config)
EGLConfig[] configs = new EGLConfig[1];
int[] numConfigs = new int[] {1};
egl.eglChooseConfig(display, attrib_list, configs, configs.length, numConfigs);
if (0 == numConfigs[0]) {
throw new RuntimeException("No matching EGL config");
}
config = configs[0];
*/
config = getEglConfig565(egl, display);
ctxt = egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, null);
}
GL createEglSurface(Surface surface) throws Surface.OutOfResourcesException {
// Check preconditions.
if (sEgl == null) {
throw new RuntimeException("egl not initialized");
}
if (sEglDisplay == null) {
throw new RuntimeException("eglDisplay not initialized");
}
if (sEglConfig == null) {
throw new RuntimeException("eglConfig not initialized");
}
if (Thread.currentThread() != mEglThread) {
throw new IllegalStateException(
"HardwareRenderer cannot be used " + "from multiple threads");
}
// In case we need to destroy an existing surface
destroySurface();
// Create an EGL surface we can render into.
if (!createSurface(surface)) {
return null;
}
initCaches();
return mEglContext.getGL();
}
public void initEGL() {
mEGL =
(EGL10)
GLDebugHelper.wrap(
EGLContext.getEGL(),
GLDebugHelper.CONFIG_CHECK_GL_ERROR | GLDebugHelper.CONFIG_CHECK_THREAD,
null);
mGLDisplay = mEGL.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] curGLVersion = new int[2];
mEGL.eglInitialize(mGLDisplay, curGLVersion);
Log.i("GL", "GL version = " + curGLVersion[0] + "." + curGLVersion[1]);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
mEGL.eglChooseConfig(mGLDisplay, mConfigSpec, configs, 1, num_config);
mGLConfig = configs[0];
mGLSurface = mEGL.eglCreateWindowSurface(mGLDisplay, mGLConfig, sv.getHolder(), null);
mGLContext = mEGL.eglCreateContext(mGLDisplay, mGLConfig, EGL10.EGL_NO_CONTEXT, null);
mEGL.eglMakeCurrent(mGLDisplay, mGLSurface, mGLSurface, mGLContext);
mGL =
(GL10)
GLDebugHelper.wrap(
mGLContext.getGL(),
GLDebugHelper.CONFIG_CHECK_GL_ERROR
| GLDebugHelper.CONFIG_CHECK_THREAD
| GLDebugHelper.CONFIG_LOG_ARGUMENT_NAMES,
null);
}
/**
* Initialize EGL for a given configuration spec.
*
* @param configSpec
*/
public void start() {
/*
* Get an EGL instance
*/
mEgl = (EGL10) EGLContext.getEGL();
/*
* Get to the default display.
*/
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
/*
* We can now initialize EGL for that display
*/
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);
mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
/*
* Create an OpenGL ES context. This must be done only once, an
* OpenGL context is a somewhat heavy object.
*/
mEglContext = mEgl.eglCreateContext(mEglDisplay, mEglConfig, EGL10.EGL_NO_CONTEXT, null);
mEglSurface = null;
}
// EGL functions
public static boolean initEGL(int majorVersion, int minorVersion, int[] attribs) {
try {
if (SDLActivity.mEGLDisplay == null) {
Log.v("SDL", "Starting up OpenGL ES " + majorVersion + "." + minorVersion);
EGL10 egl = (EGL10) EGLContext.getEGL();
EGLDisplay dpy = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int[] version = new int[2];
egl.eglInitialize(dpy, version);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
if (!egl.eglChooseConfig(dpy, attribs, configs, 1, num_config) || num_config[0] == 0) {
Log.e("SDL", "No EGL config available");
return false;
}
EGLConfig config = configs[0];
SDLActivity.mEGLDisplay = dpy;
SDLActivity.mEGLConfig = config;
SDLActivity.mGLMajor = majorVersion;
SDLActivity.mGLMinor = minorVersion;
}
return SDLActivity.createEGLSurface();
} catch (Exception e) {
Log.v("SDL", e + "");
for (StackTraceElement s : e.getStackTrace()) {
Log.v("SDL", s.toString());
}
return false;
}
}
private boolean initGLES() {
EGL10 egl = (EGL10) EGLContext.getEGL();
mEglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
Log.e(TAG, "Fail to get Display");
return false;
}
int[] version = new int[2];
if (!egl.eglInitialize(mEglDisplay, version)) {
Log.e(TAG, "Fail to eglInitialize");
return false;
}
int[] configSpec = {EGL10.EGL_NONE};
EGLConfig[] configs = new EGLConfig[1];
int[] numConfigs = new int[1];
if (!egl.eglChooseConfig(mEglDisplay, configSpec, configs, 1, numConfigs)) {
Log.e(TAG, "Fail to Choose Config");
return false;
}
mEglConfig = configs[0];
mEglContext = egl.eglCreateContext(mEglDisplay, mEglConfig, EGL10.EGL_NO_CONTEXT, null);
if (mEglContext == EGL10.EGL_NO_CONTEXT) {
Log.e(TAG, "Fail to Create OpenGL Context");
return false;
}
return true;
}
/**
* Ensures the current EGL context is the one we expect.
*
* @return {@link #SURFACE_STATE_ERROR} if the correct EGL context cannot be made current,
* {@link #SURFACE_STATE_UPDATED} if the EGL context was changed or {@link
* #SURFACE_STATE_SUCCESS} if the EGL context was the correct one
*/
int checkCurrent() {
if (mEglThread != Thread.currentThread()) {
throw new IllegalStateException(
"Hardware acceleration can only be used with a "
+ "single UI thread.\nOriginal thread: "
+ mEglThread
+ "\n"
+ "Current thread: "
+ Thread.currentThread());
}
if (!mEglContext.equals(sEgl.eglGetCurrentContext())
|| !mEglSurface.equals(sEgl.eglGetCurrentSurface(EGL_DRAW))) {
if (!sEgl.eglMakeCurrent(sEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
Log.e(LOG_TAG, "eglMakeCurrent failed " + GLUtils.getEGLErrorString(sEgl.eglGetError()));
fallback(true);
return SURFACE_STATE_ERROR;
} else {
if (mUpdateDirtyRegions) {
enableDirtyRegions();
mUpdateDirtyRegions = false;
}
return SURFACE_STATE_UPDATED;
}
}
return SURFACE_STATE_SUCCESS;
}
private boolean createSurface() {
EGL10 egl = (EGL10) EGLContext.getEGL();
mEglSurface = egl.eglCreateWindowSurface(mEglDisplay, mEglConfig, getHolder(), null);
if (mEglSurface == EGL10.EGL_NO_SURFACE) {
return false;
}
return true;
}
private void destroySurfaceForTimeWarp() {
if (null != mMainSurface) {
Log.v(TAG, "destroying mMainSurface: 0x%x", mMainSurface.hashCode());
final EGL10 egl = (EGL10) EGLContext.getEGL();
final EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
egl.eglDestroySurface(display, mMainSurface);
mMainSurface = null;
}
}
@Override
public void surfaceChanged(SurfaceHolder holder, int format, int width, int height) {
EGL10 egl = (EGL10) EGLContext.getEGL();
YabauseRunnable.lockGL();
egl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext);
YabauseRunnable.initViewport(width, height);
YabauseRunnable.unlockGL();
}
/** Initialize EGL for a given configuration spec. */
@SuppressWarnings("StatementWithEmptyBody")
public void start() {
// Log.d("EglHelper" + instanceId, "start()");
if (mEgl == null) {
// Log.d("EglHelper" + instanceId, "getting new EGL");
/*
* Get an EGL instance
*/
mEgl = (EGL10) EGLContext.getEGL();
} else {
// Log.d("EglHelper" + instanceId, "reusing EGL");
}
if (mEglDisplay == null) {
// Log.d("EglHelper" + instanceId, "getting new display");
/*
* Get to the default display.
*/
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
} else {
// Log.d("EglHelper" + instanceId, "reusing display");
}
if (mEglConfig == null) {
// Log.d("EglHelper" + instanceId, "getting new config");
/*
* We can now initialize EGL for that display
*/
int[] version = new int[2];
mEgl.eglInitialize(mEglDisplay, version);
mEglConfig = mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
} else {
// Log.d("EglHelper" + instanceId, "reusing config");
}
if (mEglContext == null) {
// Log.d("EglHelper" + instanceId, "creating new context");
/*
* Create an OpenGL ES context. This must be done only once, an OpenGL context is a somewhat heavy object.
*/
mEglContext = mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
throw new RuntimeException("createContext failed");
}
} else {
// Log.d("EglHelper" + instanceId, "reusing context");
}
mEglSurface = null;
}
public static boolean createEGLContext() {
EGL10 egl = (EGL10) EGLContext.getEGL();
int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
int contextAttrs[] =
new int[] {EGL_CONTEXT_CLIENT_VERSION, SDLActivity.mGLMajor, EGL10.EGL_NONE};
SDLActivity.mEGLContext =
egl.eglCreateContext(
SDLActivity.mEGLDisplay, SDLActivity.mEGLConfig, EGL10.EGL_NO_CONTEXT, contextAttrs);
if (SDLActivity.mEGLContext == EGL10.EGL_NO_CONTEXT) {
Log.e("SDL", "Couldn't create context");
return false;
}
return true;
}
private void createSurface() {
hasSurface = false;
if (surface != null) {
egl.eglMakeCurrent(display, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
egl.eglDestroySurface(display, surface);
}
surface = egl.eglCreateWindowSurface(display, config, surfaceHolder, null);
egl.eglMakeCurrent(display, surface, surface, eglContext);
gl = eglContext.getGL();
hasSurface = true;
}
public void initgl() {
cleanupgl();
// Create new surface. Must succeed.
surface = egl.eglCreateWindowSurface(display, config, getHolder(), null);
if (null == surface) {
throw new RuntimeException("eglCreateWindowSurface");
}
// Bind the rendering context to the surface.
if (!egl.eglMakeCurrent(display, surface, surface, ctxt)) {
throw new RuntimeException("eglMakeCurrent");
}
gl = (GL10) ctxt.getGL();
}
public static boolean createEGLSurface() {
if (SDLActivity.mEGLDisplay != null && SDLActivity.mEGLConfig != null) {
EGL10 egl = (EGL10) EGLContext.getEGL();
if (SDLActivity.mEGLContext == EGL10.EGL_NO_CONTEXT) createEGLContext();
if (SDLActivity.mEGLSurface == EGL10.EGL_NO_SURFACE) {
Log.v("SDL", "Creating new EGL Surface");
SDLActivity.mEGLSurface =
egl.eglCreateWindowSurface(
SDLActivity.mEGLDisplay, SDLActivity.mEGLConfig, SDLActivity.mSurface, null);
if (SDLActivity.mEGLSurface == EGL10.EGL_NO_SURFACE) {
Log.e("SDL", "Couldn't create surface");
return false;
}
} else Log.v("SDL", "EGL Surface remains valid");
if (egl.eglGetCurrentContext() != SDLActivity.mEGLContext) {
if (!egl.eglMakeCurrent(
SDLActivity.mEGLDisplay,
SDLActivity.mEGLSurface,
SDLActivity.mEGLSurface,
SDLActivity.mEGLContext)) {
Log.e("SDL", "Old EGL Context doesnt work, trying with a new one");
// TODO: Notify the user via a message that the old context could not be restored, and
// that textures need to be manually restored.
createEGLContext();
if (!egl.eglMakeCurrent(
SDLActivity.mEGLDisplay,
SDLActivity.mEGLSurface,
SDLActivity.mEGLSurface,
SDLActivity.mEGLContext)) {
Log.e("SDL", "Failed making EGL Context current");
return false;
}
} else Log.v("SDL", "EGL Context made current");
} else Log.v("SDL", "EGL Context remains current");
return true;
} else {
Log.e(
"SDL",
"Surface creation failed, display = "
+ SDLActivity.mEGLDisplay
+ ", config = "
+ SDLActivity.mEGLConfig);
return false;
}
}
void initializeEgl() {
synchronized (sEglLock) {
if (sEgl == null && sEglConfig == null) {
sEgl = (EGL10) EGLContext.getEGL();
// Get to the default display.
sEglDisplay = sEgl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
if (sEglDisplay == EGL_NO_DISPLAY) {
throw new RuntimeException(
"eglGetDisplay failed " + GLUtils.getEGLErrorString(sEgl.eglGetError()));
}
// We can now initialize EGL for that display
int[] version = new int[2];
if (!sEgl.eglInitialize(sEglDisplay, version)) {
throw new RuntimeException(
"eglInitialize failed " + GLUtils.getEGLErrorString(sEgl.eglGetError()));
}
checkEglErrorsForced();
sEglConfig = chooseEglConfig();
if (sEglConfig == null) {
// We tried to use EGL_SWAP_BEHAVIOR_PRESERVED_BIT, try again without
if (sDirtyRegions) {
sDirtyRegions = false;
sEglConfig = chooseEglConfig();
if (sEglConfig == null) {
throw new RuntimeException("eglConfig not initialized");
}
} else {
throw new RuntimeException("eglConfig not initialized");
}
}
}
}
ManagedEGLContext managedContext = sEglContextStorage.get();
mEglContext = managedContext != null ? managedContext.getContext() : null;
mEglThread = Thread.currentThread();
if (mEglContext == null) {
mEglContext = createContext(sEgl, sEglDisplay, sEglConfig);
sEglContextStorage.set(createManagedContext(mEglContext));
}
}
public static void deleteGLContext() {
if (SDLActivity.mEGLDisplay != null && SDLActivity.mEGLContext != EGL10.EGL_NO_CONTEXT) {
EGL10 egl = (EGL10) EGLContext.getEGL();
egl.eglMakeCurrent(
SDLActivity.mEGLDisplay,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_SURFACE,
EGL10.EGL_NO_CONTEXT);
egl.eglDestroyContext(SDLActivity.mEGLDisplay, SDLActivity.mEGLContext);
SDLActivity.mEGLContext = EGL10.EGL_NO_CONTEXT;
if (SDLActivity.mEGLSurface != EGL10.EGL_NO_SURFACE) {
egl.eglDestroySurface(SDLActivity.mEGLDisplay, SDLActivity.mEGLSurface);
SDLActivity.mEGLSurface = EGL10.EGL_NO_SURFACE;
}
}
}
// Called when we lose the surface
@Override
public void surfaceDestroyed(SurfaceHolder holder) {
Log.v("SDL", "surfaceDestroyed()");
// Call this *before* setting mIsSurfaceReady to 'false'
SDLActivity.handlePause();
SDLActivity.mIsSurfaceReady = false;
/* We have to clear the current context and destroy the egl surface here
* Otherwise there's BAD_NATIVE_WINDOW errors coming from eglCreateWindowSurface on resume
* Ref: http://stackoverflow.com/questions/8762589/eglcreatewindowsurface-on-ics-and-switching-from-2d-to-3d
*/
EGL10 egl = (EGL10) EGLContext.getEGL();
egl.eglMakeCurrent(
SDLActivity.mEGLDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
egl.eglDestroySurface(SDLActivity.mEGLDisplay, SDLActivity.mEGLSurface);
SDLActivity.mEGLSurface = EGL10.EGL_NO_SURFACE;
}
/*
* React to the creation of a new surface by creating and returning an OpenGL interface that renders to that
* surface.
*/
public GL createSurface(SurfaceHolder holder) {
/*
* The window size has changed, so we need to create a new surface.
*/
if (mEglSurface != null && mEglSurface != EGL10.EGL_NO_SURFACE) {
/*
* Unbind and destroy the old EGL surface, if there is one.
*/
mEgl.eglMakeCurrent(
mEglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
mEGLWindowSurfaceFactory.destroySurface(mEgl, mEglDisplay, mEglSurface);
}
/*
* Create an EGL surface we can render into.
*/
mEglSurface =
mEGLWindowSurfaceFactory.createWindowSurface(mEgl, mEglDisplay, mEglConfig, holder);
if (mEglSurface == null || mEglSurface == EGL10.EGL_NO_SURFACE) {
throw new RuntimeException("createWindowSurface failed");
}
/*
* Before we can issue GL commands, we need to make sure the context is current and bound to a surface.
*/
if (!mEgl.eglMakeCurrent(mEglDisplay, mEglSurface, mEglSurface, mEglContext)) {
throw new RuntimeException("eglMakeCurrent failed.");
}
GL gl = mEglContext.getGL();
if (mGLWrapper != null) {
gl = mGLWrapper.wrap(gl);
}
/*
* if ((mDebugFlags & (DEBUG_CHECK_GL_ERROR | DEBUG_LOG_GL_CALLS))!= 0) { int configFlags = 0; Writer log =
* null; if ((mDebugFlags & DEBUG_CHECK_GL_ERROR) != 0) { configFlags |= GLDebugHelper.CONFIG_CHECK_GL_ERROR; }
* if ((mDebugFlags & DEBUG_LOG_GL_CALLS) != 0) { log = new LogWriter(); } gl = GLDebugHelper.wrap(gl,
* configFlags, log); }
*/
return gl;
}
// EGL buffer flip
public static void flipEGL() {
try {
EGL10 egl = (EGL10) EGLContext.getEGL();
egl.eglWaitNative(EGL10.EGL_CORE_NATIVE_ENGINE, null);
// drawing here
egl.eglWaitGL();
egl.eglSwapBuffers(SDLActivity.mEGLDisplay, SDLActivity.mEGLSurface);
} catch (Exception e) {
Log.v("SDL", "flipEGL(): " + e);
for (StackTraceElement s : e.getStackTrace()) {
Log.v("SDL", s.toString());
}
}
}
/**
* Initialize EGL for a given configuration spec.
*
* @param configSpec
*/
public void start() {
/*
* Get an EGL instance
*/
mEgl = (EGL10) EGLContext.getEGL();
/*
* Get to the default display.
*/
mEglDisplay = mEgl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
if (mEglDisplay == EGL10.EGL_NO_DISPLAY) {
throw new RuntimeException("eglGetDisplay failed");
}
/*
* We can now initialize EGL for that display
*/
int[] version = new int[2];
if (!mEgl.eglInitialize(mEglDisplay, version)) {
throw new RuntimeException("eglInitialize failed");
}
GlView view = mGLSceneViewWeakRef.get();
if (view == null) {
mEglConfig = null;
mEglContext = null;
} else {
mEglConfig = view.mEGLConfigChooser.chooseConfig(mEgl, mEglDisplay);
/*
* Create an EGL context. We want to do this as rarely as we can, because an
* EGL context is a somewhat heavy object.
*/
mEglContext = view.mEGLContextFactory.createContext(mEgl, mEglDisplay, mEglConfig);
}
if (mEglContext == null || mEglContext == EGL10.EGL_NO_CONTEXT) {
mEglContext = null;
throwEglException("createContext");
}
mEglSurface = null;
}
public void initialize(int[] configSpec, Renderer rendererInterface) {
renderer = rendererInterface;
egl = (EGL10) EGLContext.getEGL();
display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
egl.eglInitialize(display, null);
EGLConfig[] configs = new EGLConfig[1];
int[] num_config = new int[1];
egl.eglChooseConfig(display, configSpec, configs, 1, num_config);
config = configs[0];
eglContext = egl.eglCreateContext(display, config, EGL10.EGL_NO_CONTEXT, null);
hasSurface = false;
surface = null;
createSurface();
}
private void endGLES() {
EGL10 egl = (EGL10) EGLContext.getEGL();
if (mEglSurface != null) {
// レンダリングコンテキストとの結びつけは解除
egl.eglMakeCurrent(
mEglDisplay, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_SURFACE, EGL10.EGL_NO_CONTEXT);
egl.eglDestroySurface(mEglDisplay, mEglSurface);
mEglSurface = null;
}
if (mEglContext != null) {
egl.eglDestroyContext(mEglDisplay, mEglContext);
mEglContext = null;
}
if (mEglDisplay != null) {
egl.eglTerminate(mEglDisplay);
mEglDisplay = null;
}
}
private static void checkEGLConfigChooserSupport() throws DeviceNotSupportedException {
/* Get an EGL instance. */
final EGL10 egl = (EGL10) EGLContext.getEGL();
/* Get to the default display. */
final EGLDisplay eglDisplay = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
/* We can now initialize EGL for that display. */
final int[] version = new int[2];
egl.eglInitialize(eglDisplay, version);
final ConfigChooser configChooser =
new ConfigChooser(
false); // TODO Doesn't correlate to possible multisampling request in EngineOptions...
try {
configChooser.chooseConfig(egl, eglDisplay);
} catch (final IllegalArgumentException e) {
throw new DeviceNotSupportedException(DeviceNotSupportedCause.EGLCONFIG_NOT_FOUND, e);
}
}
@Override
public void onSurfaceCreated(javax.microedition.khronos.opengles.GL10 gl, EGLConfig config) {
eglContext = ((EGL10) EGLContext.getEGL()).eglGetCurrentContext();
setupGL(gl);
logConfig(config);
updatePpi();
Mesh.invalidateAllMeshes(app);
Texture.invalidateAllTextures(app);
ShaderProgram.invalidateAllShaderPrograms(app);
FrameBuffer.invalidateAllFrameBuffers(app);
Gdx.app.log("AndroidGraphics", Mesh.getManagedStatus());
Gdx.app.log("AndroidGraphics", Texture.getManagedStatus());
Gdx.app.log("AndroidGraphics", ShaderProgram.getManagedStatus());
Gdx.app.log("AndroidGraphics", FrameBuffer.getManagedStatus());
Display display = app.getWindowManager().getDefaultDisplay();
this.width = display.getWidth();
this.height = display.getHeight();
mean = new WindowedMean(5);
this.lastFrameTime = System.nanoTime();
gl.glViewport(0, 0, this.width, this.height);
isSurfaceCreated = true;
}
private void logConfig(EGLConfig config) {
EGL10 egl = (EGL10) EGLContext.getEGL();
EGLDisplay display = egl.eglGetDisplay(EGL10.EGL_DEFAULT_DISPLAY);
int r = getAttrib(egl, display, config, EGL10.EGL_RED_SIZE, 0);
int g = getAttrib(egl, display, config, EGL10.EGL_GREEN_SIZE, 0);
int b = getAttrib(egl, display, config, EGL10.EGL_BLUE_SIZE, 0);
int a = getAttrib(egl, display, config, EGL10.EGL_ALPHA_SIZE, 0);
int d = getAttrib(egl, display, config, EGL10.EGL_DEPTH_SIZE, 0);
int s = getAttrib(egl, display, config, EGL10.EGL_STENCIL_SIZE, 0);
int samples =
Math.max(
getAttrib(egl, display, config, EGL10.EGL_SAMPLES, 0),
getAttrib(egl, display, config, GdxEglConfigChooser.EGL_COVERAGE_SAMPLES_NV, 0));
boolean coverageSample =
getAttrib(egl, display, config, GdxEglConfigChooser.EGL_COVERAGE_SAMPLES_NV, 0) != 0;
Gdx.app.log("AndroidGraphics", "framebuffer: (" + r + ", " + g + ", " + b + ", " + a + ")");
Gdx.app.log("AndroidGraphics", "depthbuffer: (" + d + ")");
Gdx.app.log("AndroidGraphics", "stencilbuffer: (" + s + ")");
Gdx.app.log("AndroidGraphics", "samples: (" + samples + ")");
Gdx.app.log("AndroidGraphics", "coverage sampling: (" + coverageSample + ")");
bufferFormat = new BufferFormat(r, g, b, a, d, s, samples, coverageSample);
}