ndk/apps/hello-gl2/project/src/com/android/gl2jni/GL2JNIView.java - platform/development - Git at Google

 /*
  * Copyright (C) 2009 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */

 package com.android.gl2jni;
 /*
  * Copyright (C) 2008 The Android Open Source Project
  *
  * Licensed under the Apache License, Version 2.0 (the "License");
  * you may not use this file except in compliance with the License.
  * You may obtain a copy of the License at
  *
  *      http://www.apache.org/licenses/LICENSE-2.0
  *
  * Unless required by applicable law or agreed to in writing, software
  * distributed under the License is distributed on an "AS IS" BASIS,
  * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */


 import android.content.Context;
 import android.graphics.PixelFormat;
 import android.opengl.GLSurfaceView;
 import android.util.AttributeSet;
 import android.util.Log;
 import android.view.KeyEvent;
 import android.view.MotionEvent;

 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.opengles.GL10;

 /**
  * A simple GLSurfaceView sub-class that demonstrate how to perform
  * OpenGL ES 2.0 rendering into a GL Surface. Note the following important
  * details:
  *
  * - The class must use a custom context factory to enable 2.0 rendering.
  *   See ContextFactory class definition below.
  *
  * - The class must use a custom EGLConfigChooser to be able to select
  *   an EGLConfig that supports 2.0. This is done by providing a config
  *   specification to eglChooseConfig() that has the attribute
  *   EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
  *   set. See ConfigChooser class definition below.
  *
  * - The class must select the surface's format, then choose an EGLConfig
  *   that matches it exactly (with regards to red/green/blue/alpha channels
  *   bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
  */
 class GL2JNIView extends GLSurfaceView {
     private static String TAG = "GL2JNIView";
     private static final boolean DEBUG = false;

     public GL2JNIView(Context context) {
         super(context);
         init(false, 0, 0);
     }

     public GL2JNIView(Context context, boolean translucent, int depth, int stencil) {
         super(context);
         init(translucent, depth, stencil);
     }

     private void init(boolean translucent, int depth, int stencil) {

         /* By default, GLSurfaceView() creates a RGB_565 opaque surface.
          * If we want a translucent one, we should change the surface's
          * format here, using PixelFormat.TRANSLUCENT for GL Surfaces
          * is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
          */
         if (translucent) {
             this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
         }

         /* Setup the context factory for 2.0 rendering.
          * See ContextFactory class definition below
          */
         setEGLContextFactory(new ContextFactory());

         /* We need to choose an EGLConfig that matches the format of
          * our surface exactly. This is going to be done in our
          * custom config chooser. See ConfigChooser class definition
          * below.
          */
         setEGLConfigChooser( translucent ?
                              new ConfigChooser(8, 8, 8, 8, depth, stencil) :
                              new ConfigChooser(5, 6, 5, 0, depth, stencil) );

         /* Set the renderer responsible for frame rendering */
         setRenderer(new Renderer());
     }

     private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
         private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
         public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
             Log.w(TAG, "creating OpenGL ES 2.0 context");
             checkEglError("Before eglCreateContext", egl);
             int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
             EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
             checkEglError("After eglCreateContext", egl);
             return context;
         }

         public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
             egl.eglDestroyContext(display, context);
         }
     }

     private static void checkEglError(String prompt, EGL10 egl) {
         int error;
         while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
             Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
         }
     }

     private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {

         public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
             mRedSize = r;
             mGreenSize = g;
             mBlueSize = b;
             mAlphaSize = a;
             mDepthSize = depth;
             mStencilSize = stencil;
         }

         /* 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.
          */
         private static int EGL_OPENGL_ES2_BIT = 4;
         private static int[] s_configAttribs2 =
         {
             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
         };

         public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {

             /* Get the number of minimally matching EGL configurations
              */
             int[] num_config = new int[1];
             egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);

             int numConfigs = num_config[0];

             if (numConfigs <= 0) {
                 throw new IllegalArgumentException("No configs match configSpec");
             }

             /* Allocate then read the array of minimally matching EGL configs
              */
             EGLConfig[] configs = new EGLConfig[numConfigs];
             egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);

             if (DEBUG) {
                  printConfigs(egl, display, configs);
             }
             /* Now return the "best" one
              */
             return chooseConfig(egl, display, configs);
         }

         public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
                 EGLConfig[] configs) {
             for(EGLConfig config : configs) {
                 int d = findConfigAttrib(egl, display, config,
                         EGL10.EGL_DEPTH_SIZE, 0);
                 int s = findConfigAttrib(egl, display, config,
                         EGL10.EGL_STENCIL_SIZE, 0);

                 // We need at least mDepthSize and mStencilSize bits
                 if (d < mDepthSize || s < mStencilSize)
                     continue;

                 // We want an *exact* match for red/green/blue/alpha
                 int r = findConfigAttrib(egl, display, config,
                         EGL10.EGL_RED_SIZE, 0);
                 int g = findConfigAttrib(egl, display, config,
                             EGL10.EGL_GREEN_SIZE, 0);
                 int b = findConfigAttrib(egl, display, config,
                             EGL10.EGL_BLUE_SIZE, 0);
                 int a = findConfigAttrib(egl, display, config,
                         EGL10.EGL_ALPHA_SIZE, 0);

                 if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
                     return config;
             }
             return null;
         }

         private int findConfigAttrib(EGL10 egl, EGLDisplay display,
                 EGLConfig config, int attribute, int defaultValue) {

             if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
                 return mValue[0];
             }
             return defaultValue;
         }

         private void printConfigs(EGL10 egl, EGLDisplay display,
             EGLConfig[] configs) {
             int numConfigs = configs.length;
             Log.w(TAG, String.format("%d configurations", numConfigs));
             for (int i = 0; i < numConfigs; i++) {
                 Log.w(TAG, String.format("Configuration %d:\n", i));
                 printConfig(egl, display, configs[i]);
             }
         }

         private void printConfig(EGL10 egl, EGLDisplay display,
                 EGLConfig config) {
             int[] attributes = {
                     EGL10.EGL_BUFFER_SIZE,
                     EGL10.EGL_ALPHA_SIZE,
                     EGL10.EGL_BLUE_SIZE,
                     EGL10.EGL_GREEN_SIZE,
                     EGL10.EGL_RED_SIZE,
                     EGL10.EGL_DEPTH_SIZE,
                     EGL10.EGL_STENCIL_SIZE,
                     EGL10.EGL_CONFIG_CAVEAT,
                     EGL10.EGL_CONFIG_ID,
                     EGL10.EGL_LEVEL,
                     EGL10.EGL_MAX_PBUFFER_HEIGHT,
                     EGL10.EGL_MAX_PBUFFER_PIXELS,
                     EGL10.EGL_MAX_PBUFFER_WIDTH,
                     EGL10.EGL_NATIVE_RENDERABLE,
                     EGL10.EGL_NATIVE_VISUAL_ID,
                     EGL10.EGL_NATIVE_VISUAL_TYPE,
                     0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
                     EGL10.EGL_SAMPLES,
                     EGL10.EGL_SAMPLE_BUFFERS,
                     EGL10.EGL_SURFACE_TYPE,
                     EGL10.EGL_TRANSPARENT_TYPE,
                     EGL10.EGL_TRANSPARENT_RED_VALUE,
                     EGL10.EGL_TRANSPARENT_GREEN_VALUE,
                     EGL10.EGL_TRANSPARENT_BLUE_VALUE,
                     0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
                     0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
                     0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
                     0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
                     EGL10.EGL_LUMINANCE_SIZE,
                     EGL10.EGL_ALPHA_MASK_SIZE,
                     EGL10.EGL_COLOR_BUFFER_TYPE,
                     EGL10.EGL_RENDERABLE_TYPE,
                     0x3042 // EGL10.EGL_CONFORMANT
             };
             String[] names = {
                     "EGL_BUFFER_SIZE",
                     "EGL_ALPHA_SIZE",
                     "EGL_BLUE_SIZE",
                     "EGL_GREEN_SIZE",
                     "EGL_RED_SIZE",
                     "EGL_DEPTH_SIZE",
                     "EGL_STENCIL_SIZE",
                     "EGL_CONFIG_CAVEAT",
                     "EGL_CONFIG_ID",
                     "EGL_LEVEL",
                     "EGL_MAX_PBUFFER_HEIGHT",
                     "EGL_MAX_PBUFFER_PIXELS",
                     "EGL_MAX_PBUFFER_WIDTH",
                     "EGL_NATIVE_RENDERABLE",
                     "EGL_NATIVE_VISUAL_ID",
                     "EGL_NATIVE_VISUAL_TYPE",
                     "EGL_PRESERVED_RESOURCES",
                     "EGL_SAMPLES",
                     "EGL_SAMPLE_BUFFERS",
                     "EGL_SURFACE_TYPE",
                     "EGL_TRANSPARENT_TYPE",
                     "EGL_TRANSPARENT_RED_VALUE",
                     "EGL_TRANSPARENT_GREEN_VALUE",
                     "EGL_TRANSPARENT_BLUE_VALUE",
                     "EGL_BIND_TO_TEXTURE_RGB",
                     "EGL_BIND_TO_TEXTURE_RGBA",
                     "EGL_MIN_SWAP_INTERVAL",
                     "EGL_MAX_SWAP_INTERVAL",
                     "EGL_LUMINANCE_SIZE",
                     "EGL_ALPHA_MASK_SIZE",
                     "EGL_COLOR_BUFFER_TYPE",
                     "EGL_RENDERABLE_TYPE",
                     "EGL_CONFORMANT"
             };
             int[] value = new int[1];
             for (int i = 0; i < attributes.length; i++) {
                 int attribute = attributes[i];
                 String name = names[i];
                 if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
                     Log.w(TAG, String.format("  %s: %d\n", name, value[0]));
                 } else {
                     // Log.w(TAG, String.format("  %s: failed\n", name));
                     while (egl.eglGetError() != EGL10.EGL_SUCCESS);
                 }
             }
         }

         // Subclasses can adjust these values:
         protected int mRedSize;
         protected int mGreenSize;
         protected int mBlueSize;
         protected int mAlphaSize;
         protected int mDepthSize;
         protected int mStencilSize;
         private int[] mValue = new int[1];
     }

     private static class Renderer implements GLSurfaceView.Renderer {
         public void onDrawFrame(GL10 gl) {
             GL2JNILib.step();
         }

         public void onSurfaceChanged(GL10 gl, int width, int height) {
             GL2JNILib.init(width, height);
         }

         public void onSurfaceCreated(GL10 gl, EGLConfig config) {
             // Do nothing.
         }
     }
 }
	/*
	* Copyright (C) 2009 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/

	package com.android.gl2jni;
	/*
	* Copyright (C) 2008 The Android Open Source Project
	*
	* Licensed under the Apache License, Version 2.0 (the "License");
	* you may not use this file except in compliance with the License.
	* You may obtain a copy of the License at
	*
	* http://www.apache.org/licenses/LICENSE-2.0
	*
	* Unless required by applicable law or agreed to in writing, software
	* distributed under the License is distributed on an "AS IS" BASIS,
	* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
	* See the License for the specific language governing permissions and
	* limitations under the License.
	*/


	import android.content.Context;
	import android.graphics.PixelFormat;
	import android.opengl.GLSurfaceView;
	import android.util.AttributeSet;
	import android.util.Log;
	import android.view.KeyEvent;
	import android.view.MotionEvent;

	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.opengles.GL10;

	/**
	* A simple GLSurfaceView sub-class that demonstrate how to perform
	* OpenGL ES 2.0 rendering into a GL Surface. Note the following important
	* details:
	*
	* - The class must use a custom context factory to enable 2.0 rendering.
	* See ContextFactory class definition below.
	*
	* - The class must use a custom EGLConfigChooser to be able to select
	* an EGLConfig that supports 2.0. This is done by providing a config
	* specification to eglChooseConfig() that has the attribute
	* EGL10.ELG_RENDERABLE_TYPE containing the EGL_OPENGL_ES2_BIT flag
	* set. See ConfigChooser class definition below.
	*
	* - The class must select the surface's format, then choose an EGLConfig
	* that matches it exactly (with regards to red/green/blue/alpha channels
	* bit depths). Failure to do so would result in an EGL_BAD_MATCH error.
	*/
	class GL2JNIView extends GLSurfaceView {
	private static String TAG = "GL2JNIView";
	private static final boolean DEBUG = false;

	public GL2JNIView(Context context) {
	super(context);
	init(false, 0, 0);
	}

	public GL2JNIView(Context context, boolean translucent, int depth, int stencil) {
	super(context);
	init(translucent, depth, stencil);
	}

	private void init(boolean translucent, int depth, int stencil) {

	/* By default, GLSurfaceView() creates a RGB_565 opaque surface.
	* If we want a translucent one, we should change the surface's
	* format here, using PixelFormat.TRANSLUCENT for GL Surfaces
	* is interpreted as any 32-bit surface with alpha by SurfaceFlinger.
	*/
	if (translucent) {
	this.getHolder().setFormat(PixelFormat.TRANSLUCENT);
	}

	/* Setup the context factory for 2.0 rendering.
	* See ContextFactory class definition below
	*/
	setEGLContextFactory(new ContextFactory());

	/* We need to choose an EGLConfig that matches the format of
	* our surface exactly. This is going to be done in our
	* custom config chooser. See ConfigChooser class definition
	* below.
	*/
	setEGLConfigChooser( translucent ?
	new ConfigChooser(8, 8, 8, 8, depth, stencil) :
	new ConfigChooser(5, 6, 5, 0, depth, stencil) );

	/* Set the renderer responsible for frame rendering */
	setRenderer(new Renderer());
	}

	private static class ContextFactory implements GLSurfaceView.EGLContextFactory {
	private static int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
	public EGLContext createContext(EGL10 egl, EGLDisplay display, EGLConfig eglConfig) {
	Log.w(TAG, "creating OpenGL ES 2.0 context");
	checkEglError("Before eglCreateContext", egl);
	int[] attrib_list = {EGL_CONTEXT_CLIENT_VERSION, 2, EGL10.EGL_NONE };
	EGLContext context = egl.eglCreateContext(display, eglConfig, EGL10.EGL_NO_CONTEXT, attrib_list);
	checkEglError("After eglCreateContext", egl);
	return context;
	}

	public void destroyContext(EGL10 egl, EGLDisplay display, EGLContext context) {
	egl.eglDestroyContext(display, context);
	}
	}

	private static void checkEglError(String prompt, EGL10 egl) {
	int error;
	while ((error = egl.eglGetError()) != EGL10.EGL_SUCCESS) {
	Log.e(TAG, String.format("%s: EGL error: 0x%x", prompt, error));
	}
	}

	private static class ConfigChooser implements GLSurfaceView.EGLConfigChooser {

	public ConfigChooser(int r, int g, int b, int a, int depth, int stencil) {
	mRedSize = r;
	mGreenSize = g;
	mBlueSize = b;
	mAlphaSize = a;
	mDepthSize = depth;
	mStencilSize = stencil;
	}

	/* 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.
	*/
	private static int EGL_OPENGL_ES2_BIT = 4;
	private static int[] s_configAttribs2 =
	{
	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
	};

	public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display) {

	/* Get the number of minimally matching EGL configurations
	*/
	int[] num_config = new int[1];
	egl.eglChooseConfig(display, s_configAttribs2, null, 0, num_config);

	int numConfigs = num_config[0];

	if (numConfigs <= 0) {
	throw new IllegalArgumentException("No configs match configSpec");
	}

	/* Allocate then read the array of minimally matching EGL configs
	*/
	EGLConfig[] configs = new EGLConfig[numConfigs];
	egl.eglChooseConfig(display, s_configAttribs2, configs, numConfigs, num_config);

	if (DEBUG) {
	printConfigs(egl, display, configs);
	}
	/* Now return the "best" one
	*/
	return chooseConfig(egl, display, configs);
	}

	public EGLConfig chooseConfig(EGL10 egl, EGLDisplay display,
	EGLConfig[] configs) {
	for(EGLConfig config : configs) {
	int d = findConfigAttrib(egl, display, config,
	EGL10.EGL_DEPTH_SIZE, 0);
	int s = findConfigAttrib(egl, display, config,
	EGL10.EGL_STENCIL_SIZE, 0);

	// We need at least mDepthSize and mStencilSize bits
	if (d < mDepthSize \|\| s < mStencilSize)
	continue;

	// We want an exact match for red/green/blue/alpha
	int r = findConfigAttrib(egl, display, config,
	EGL10.EGL_RED_SIZE, 0);
	int g = findConfigAttrib(egl, display, config,
	EGL10.EGL_GREEN_SIZE, 0);
	int b = findConfigAttrib(egl, display, config,
	EGL10.EGL_BLUE_SIZE, 0);
	int a = findConfigAttrib(egl, display, config,
	EGL10.EGL_ALPHA_SIZE, 0);

	if (r == mRedSize && g == mGreenSize && b == mBlueSize && a == mAlphaSize)
	return config;
	}
	return null;
	}

	private int findConfigAttrib(EGL10 egl, EGLDisplay display,
	EGLConfig config, int attribute, int defaultValue) {

	if (egl.eglGetConfigAttrib(display, config, attribute, mValue)) {
	return mValue[0];
	}
	return defaultValue;
	}

	private void printConfigs(EGL10 egl, EGLDisplay display,
	EGLConfig[] configs) {
	int numConfigs = configs.length;
	Log.w(TAG, String.format("%d configurations", numConfigs));
	for (int i = 0; i < numConfigs; i++) {
	Log.w(TAG, String.format("Configuration %d:\n", i));
	printConfig(egl, display, configs[i]);
	}
	}

	private void printConfig(EGL10 egl, EGLDisplay display,
	EGLConfig config) {
	int[] attributes = {
	EGL10.EGL_BUFFER_SIZE,
	EGL10.EGL_ALPHA_SIZE,
	EGL10.EGL_BLUE_SIZE,
	EGL10.EGL_GREEN_SIZE,
	EGL10.EGL_RED_SIZE,
	EGL10.EGL_DEPTH_SIZE,
	EGL10.EGL_STENCIL_SIZE,
	EGL10.EGL_CONFIG_CAVEAT,
	EGL10.EGL_CONFIG_ID,
	EGL10.EGL_LEVEL,
	EGL10.EGL_MAX_PBUFFER_HEIGHT,
	EGL10.EGL_MAX_PBUFFER_PIXELS,
	EGL10.EGL_MAX_PBUFFER_WIDTH,
	EGL10.EGL_NATIVE_RENDERABLE,
	EGL10.EGL_NATIVE_VISUAL_ID,
	EGL10.EGL_NATIVE_VISUAL_TYPE,
	0x3030, // EGL10.EGL_PRESERVED_RESOURCES,
	EGL10.EGL_SAMPLES,
	EGL10.EGL_SAMPLE_BUFFERS,
	EGL10.EGL_SURFACE_TYPE,
	EGL10.EGL_TRANSPARENT_TYPE,
	EGL10.EGL_TRANSPARENT_RED_VALUE,
	EGL10.EGL_TRANSPARENT_GREEN_VALUE,
	EGL10.EGL_TRANSPARENT_BLUE_VALUE,
	0x3039, // EGL10.EGL_BIND_TO_TEXTURE_RGB,
	0x303A, // EGL10.EGL_BIND_TO_TEXTURE_RGBA,
	0x303B, // EGL10.EGL_MIN_SWAP_INTERVAL,
	0x303C, // EGL10.EGL_MAX_SWAP_INTERVAL,
	EGL10.EGL_LUMINANCE_SIZE,
	EGL10.EGL_ALPHA_MASK_SIZE,
	EGL10.EGL_COLOR_BUFFER_TYPE,
	EGL10.EGL_RENDERABLE_TYPE,
	0x3042 // EGL10.EGL_CONFORMANT
	};
	String[] names = {
	"EGL_BUFFER_SIZE",
	"EGL_ALPHA_SIZE",
	"EGL_BLUE_SIZE",
	"EGL_GREEN_SIZE",
	"EGL_RED_SIZE",
	"EGL_DEPTH_SIZE",
	"EGL_STENCIL_SIZE",
	"EGL_CONFIG_CAVEAT",
	"EGL_CONFIG_ID",
	"EGL_LEVEL",
	"EGL_MAX_PBUFFER_HEIGHT",
	"EGL_MAX_PBUFFER_PIXELS",
	"EGL_MAX_PBUFFER_WIDTH",
	"EGL_NATIVE_RENDERABLE",
	"EGL_NATIVE_VISUAL_ID",
	"EGL_NATIVE_VISUAL_TYPE",
	"EGL_PRESERVED_RESOURCES",
	"EGL_SAMPLES",
	"EGL_SAMPLE_BUFFERS",
	"EGL_SURFACE_TYPE",
	"EGL_TRANSPARENT_TYPE",
	"EGL_TRANSPARENT_RED_VALUE",
	"EGL_TRANSPARENT_GREEN_VALUE",
	"EGL_TRANSPARENT_BLUE_VALUE",
	"EGL_BIND_TO_TEXTURE_RGB",
	"EGL_BIND_TO_TEXTURE_RGBA",
	"EGL_MIN_SWAP_INTERVAL",
	"EGL_MAX_SWAP_INTERVAL",
	"EGL_LUMINANCE_SIZE",
	"EGL_ALPHA_MASK_SIZE",
	"EGL_COLOR_BUFFER_TYPE",
	"EGL_RENDERABLE_TYPE",
	"EGL_CONFORMANT"
	};
	int[] value = new int[1];
	for (int i = 0; i < attributes.length; i++) {
	int attribute = attributes[i];
	String name = names[i];
	if ( egl.eglGetConfigAttrib(display, config, attribute, value)) {
	Log.w(TAG, String.format(" %s: %d\n", name, value[0]));
	} else {
	// Log.w(TAG, String.format(" %s: failed\n", name));
	while (egl.eglGetError() != EGL10.EGL_SUCCESS);
	}
	}
	}

	// Subclasses can adjust these values:
	protected int mRedSize;
	protected int mGreenSize;
	protected int mBlueSize;
	protected int mAlphaSize;
	protected int mDepthSize;
	protected int mStencilSize;
	private int[] mValue = new int[1];
	}

	private static class Renderer implements GLSurfaceView.Renderer {
	public void onDrawFrame(GL10 gl) {
	GL2JNILib.step();
	}

	public void onSurfaceChanged(GL10 gl, int width, int height) {
	GL2JNILib.init(width, height);
	}

	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
	// Do nothing.
	}
	}
	}