How to detect OpenGL capabilities without creating a GLSurfaceView (Android)

Question

I am trying to access the OpenGL capability of the phone before deciding whether to use OpenGL or Canvas for graphics puposes. However, all the functions that I can read documentation on requires you to already have a valid OpenGL context (namely, create a GLSurfaceView and assign it a rendered. Then check the OpenGL parameters in the onSurfaceCreated).

So, is there a way to check the extensions, renderer name and max texture size capability of the phone BEFORE having to create any OpenGL views?

score 2 · Answer 1 · answered Jan 29 '11 at 19:31

After searching, I came to the conclusion that I need a valid GL context before I can query it for its capability. That, in turn requires a Surface, and so on. Basicly, you need to create the OpenGL surface before you can check what it supports.

So here is what I ended up doing: I created a new activity (GraphicChooser, I need to work on my classes names...) that is launched instead of my normal activity. This activity creates a GLSurfaceView, which check the capability of the device in onSurfaceCreated. Depending on what is found, it starts the main activity with some flags about the graphic options to use, then exits. Each activity mode is set to singleTask so quitting one doesn't affect the other and there can only be a single instance of each. For example, after hitting the home button and you restart the GraphicChooser activity, it will fire a new intent to main activity, which is still active but will not create a new one.

It is very crude and there certainly is a better way to do it, but I couldn't find it. The main downside is that each time you start the activity, there is the overhead of creating an extra one.

package com.greencod.pinball.android;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.app.Activity;
import android.content.Intent;
import android.opengl.GLSurfaceView;
import android.os.Bundle;
import android.util.Log;
import android.view.Display;

public class GraphicChooser extends Activity {

   private GLSurfaceView mGLView;

   @Override
   protected void onCreate(Bundle savedInstanceState) {
       super.onCreate(savedInstanceState);

       Log.d("Graphic Chooser", "onCreate: create view and renderer.");
       // get the screen size
       Display display = getWindowManager().getDefaultDisplay();
       int width = display.getWidth();
       int height = display.getHeight();

       mGLView = new GLSurfaceView(this);
       mGLView.setRenderer(new GraphicChooserRenderer(this, width, height));
       setContentView(mGLView);
   }

   @Override
   protected void onResume() {
      super.onResume();

      Log.d("Graphic Chooser", "onResume: purely for testing purpose.");
   }

   @Override
   protected void onDestroy() {
      super.onDestroy();

      Log.d("Graphic Chooser", "onDestroy: Bye bye.");
   }

   static final int GAME_ACTIVITY_REQUEST_CODE = 10;
   public void launchGraphics(int type)
   {
      // launch game activity and kill this activity
      Intent i = new Intent(this, PinballActivity.class);
      i.putExtra("Graphics", type);
      // the activity requested should go in a new task, so even if we are passing
      // a request code, we will not get it when the new activity stops, but right now
      // as a 'cancel' request. That is ok, just quit this activity then.
      startActivityForResult(i, GAME_ACTIVITY_REQUEST_CODE);
   }

   @Override
   protected void onActivityResult(int requestCode, int resultCode, Intent data) {
      super.onActivityResult(requestCode, resultCode, data);
      if( requestCode == GAME_ACTIVITY_REQUEST_CODE )
         finish();
   }
}

class GraphicChooserRenderer implements GLSurfaceView.Renderer{

   GraphicChooser _activity;
   final int _width, _height;
   public GraphicChooserRenderer( GraphicChooser activity, int width, int height )
   {
      _activity = activity;
      _width = width;
      _height = height;
   }

   final int GRAPHICS_CANVAS = 0;
   final int GRAPHICS_OPENGL_DRAW_TEXTURE = 1;

   public void determineGraphicSupport(GL10 gl)
   {
      int _graphicEngine = GRAPHICS_CANVAS;

      String extensions = gl.glGetString(GL10.GL_EXTENSIONS); 
//      String version = GLES10.glGetString(GL10.GL_VERSION);
      String renderer = gl.glGetString(GL10.GL_RENDERER);
      boolean isSoftwareRenderer = renderer.contains("PixelFlinger");
      boolean supportsDrawTexture = extensions.contains("draw_texture");
      int[] arGlMaxTextureSize = new int[1];
      gl.glGetIntegerv( GL10.GL_MAX_TEXTURE_SIZE, arGlMaxTextureSize, 0 );

      if( !isSoftwareRenderer && supportsDrawTexture && _width >= 480 && _height >= 800 
            && arGlMaxTextureSize[0] >= 2048 )
         _graphicEngine = GRAPHICS_OPENGL_DRAW_TEXTURE;
      else
         _graphicEngine = GRAPHICS_CANVAS;

      Log.i("pinball", "Graphics using " + (_graphicEngine==GRAPHICS_CANVAS?"Canvas":"OpenGL EOS draw texture")
            + ". OpenGL renderer: " + renderer
            + ". Software renderer: " + isSoftwareRenderer
            + ". Support draw texture: " + supportsDrawTexture 
            + ". Texture max size: " + arGlMaxTextureSize[0]
            + ". Resolution: " + _width + "x" + _height );

      _activity.launchGraphics(_graphicEngine);
   }

   public void onSurfaceCreated(GL10 gl, EGLConfig config) {
      determineGraphicSupport(gl);
   }

   public void onSurfaceChanged(GL10 gl, int w, int h) {
      gl.glViewport(0, 0, w, h);
   }

   public void onDrawFrame(GL10 gl) {
      gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);
   }  
}

Hi ADB, I am facing this problem for run my GLSurfaceview in android. here i used opgneles2.0 technology. please see me problem in this stackoverflow link and help me from this problem.. http://stackoverflow.com/questions/17187032/why-my-opengl-output-differs-for-various-devices — harikrishnan, Jun 19 '13 at 12:53

Anjali Wheeler · Answer 2 · 2017-08-23T21:58:48.623

1

For extensions:

EGLDisplay display = EGL14.eglGetDisplay(EGL14.EGL_DEFAULT_DISPLAY);
String extensions = EGL14.eglQueryString(display, EGL14.EGL_EXTENSIONS);

edited Aug 23 '17 at 21:58

answered Aug 22 '17 at 20:25

Anjali Wheeler

21
2

score 0 · Answer 3 · answered Apr 10 '13 at 01:20

0

Courtesy of our friends at Google:

Run the following code on your target devices to determine what texture compression formats are supported:

String extenstions = javax.microedition.khronos.opengles.GL10.glGetString(GL10.GL_EXTENSIONS);

http://developer.android.com/guide/topics/graphics/opengl.html docs

answered Apr 10 '13 at 01:20

TheDudeAbides

122
6

@harikrishnan use this method against a proxy within your chosen environment (e.g., emulator, real phone, or java) to gain specific information that will aid you making some decision. – TheDudeAbides Aug 01 '13 at 12:34
2

Doesn't work as glGetString is non-static, and still requires a valid context – 3c71 Apr 20 '14 at 08:17

score 0 · Answer 4 · answered Apr 10 '21 at 20:44

Actually, you can use an offscreen surface: eglCreatePbufferSurface().

Example:

import android.opengl.GLES20;

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.egl.EGLSurface;

import static javax.microedition.khronos.egl.EGL10.EGL_DEFAULT_DISPLAY;
import static javax.microedition.khronos.egl.EGL10.EGL_NONE;
import static javax.microedition.khronos.egl.EGL10.EGL_NO_CONTEXT;
import static javax.microedition.khronos.egl.EGL10.EGL_NO_SURFACE;

// ...

public static final int EGL_CONTEXT_CLIENT_VERSION = 0x3098;
public static final int EGL_OPENGL_ES2_BIT = 0x0004;

// ...

private static final String eglExtensions;
private static final Point maxSize;

static {
    final EGL10 egl = (EGL10) EGLContext.getEGL();
    final EGLDisplay eglDisplay = egl.eglGetDisplay(EGL_DEFAULT_DISPLAY);
    final int[] eglVer = new int[2];
    egl.eglInitialize(eglDisplay, eglVer);
    eglExtensions = egl.eglQueryString(eglDisplay, EGL10.EGL_EXTENSIONS);
    Log.i("GL_CAPS", eglExtensions);
    final EGLConfig eglConfig = chooseEglConfig(egl, eglDisplay, config0Depth);
    final EGLContext eglContext = egl.eglCreateContext(eglDisplay, eglConfig,
            EGL_NO_CONTEXT,
            new int[]{EGL_CONTEXT_CLIENT_VERSION, 2, EGL_NONE});
    final EGLSurface eglSurface = egl.eglCreatePbufferSurface(eglDisplay, eglConfig, null);
    try {
        if (!egl.eglMakeCurrent(eglDisplay, eglSurface, eglSurface, eglContext))
            throw new RendererException("GLError: " + egl.eglGetError());
        final int[] maxTexSize = new int[1];
        GLES20.glGetIntegerv(GLES20.GL_MAX_TEXTURE_SIZE, maxTexSize, 0);
        maxSize = new Point(maxTexSize[0], maxTexSize[0]);
        Log.i("GL_CAPS", "GL_MAX_TEXTURE_SIZE: " + maxSize.x);
    } finally {
        egl.eglMakeCurrent(eglDisplay, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
        egl.eglDestroyContext(eglDisplay, eglContext);
        egl.eglDestroySurface(eglDisplay, eglSurface);
    }
}

@NonNull
public static EGLConfig chooseEglConfig(@NonNull final EGL10 egl,
                                        @NonNull final EGLDisplay eglDisplay,
                                        @NonNull final int[] config) {
    final int[] configsCount = new int[]{0};
    final EGLConfig[] configs = new EGLConfig[]{null};
    egl.eglChooseConfig(eglDisplay, config, configs, 1, configsCount);
    if (configs[0] == null) throw new RendererException("No good GL config found");
    return configs[0];
}

public static final int[] config0Depth = new int[]{
        EGL_RENDERABLE_TYPE, EGL_OPENGL_ES2_BIT,
        EGL_RED_SIZE, 8,
        EGL_GREEN_SIZE, 8,
        EGL_BLUE_SIZE, 8,
        EGL_ALPHA_SIZE, 8,
        EGL_DEPTH_SIZE, 0,
        EGL_STENCIL_SIZE, 0,
        EGL_NONE
};

How to detect OpenGL capabilities without creating a GLSurfaceView (Android)

4 Answers4

Linked