Java – Triangle OpenGL in Android

I’m new to OpenGL, so I’m using an android developer’s guide. I’ve done everything they say, but it shows an error that forces a shutdown.

The following error is displayed in my cat log file

03-30 20:13:14.342: E/AndroidRuntime(317): FATAL EXCEPTION: GLThread 8
03-30 20:13:14.342: E/AndroidRuntime(317): java.lang.IllegalArgumentException: No configs match configSpec
03-30 20:13:14.342: E/AndroidRuntime(317):  at android.opengl.GLSurfaceView$BaseConfigChooser.chooseConfig(GLSurfaceView.java:760)
03-30 20:13:14.342: E/AndroidRuntime(317):  at android.opengl.GLSurfaceView$EglHelper.start(GLSurfaceView.java:916)
03-30 20:13:14.342: E/AndroidRuntime(317):  at android.opengl.GLSurfaceView$GLThread.guardedRun(GLSurfaceView.java:1246)
03-30 20:13:14.342: E/AndroidRuntime(317):  at android.opengl.GLSurfaceView$GLThread.run(GLSurfaceView.java:1116)

My list file is as follows

<?xml version="1.0" encoding="utf-8"?>
<manifest xmlns:android="http://schemas.android.com/apk/res/android"
    package="com.example.opengl"
    android:versionCode="1"
    android:versionName="1.0" >

<uses-sdk android:minSdkVersion="8" />
    <uses-feature android:glEsVersion="0x00020000" android:required="true" />

<application
        android:icon="@drawable/ic_launcher"
        android:label="@string/app_name" >
        <activity
            android:name=". HelloOpenGLES20"
            android:label="@string/app_name" >
            <intent-filter>
                <action android:name="android.intent.action.MAIN" />

<category android:name="android.intent.category.LAUNCHER" />
            </intent-filter>
        </activity>
    </application>

</manifest>

My activity lesson is as follows

import android.app.Activity;
import android.content.Context;
import android.opengl.GLSurfaceView;
import android.os.Bundle;

public class HelloOpenGLES20 extends Activity {

private GLSurfaceView mGLView;

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

 Create a GLSurfaceView instance and set it
         as the ContentView for this Activity
        mGLView = new HelloOpenGLES20SurfaceView(this);
        setContentView(mGLView);
    }

@Override
    protected void onPause() {
        super.onPause();
         The following call pauses the rendering thread.
         If your OpenGL application is memory intensive,
         you should consider de-allocating objects that
         consume significant memory here.
        mGLView.onPause();
    }

@Override
    protected void onResume() {
        super.onResume();
         The following call resumes a paused rendering thread.
         If you de-allocated graphic objects for onPause()
         this is a good place to re-allocate them.
        mGLView.onResume();
    }
}

class HelloOpenGLES20SurfaceView extends GLSurfaceView {

public HelloOpenGLES20SurfaceView(Context context){
        super(context);

 Create an OpenGL ES 2.0 context.
        setEGLContextClientVersion(2);
         Set the Renderer for drawing on the GLSurfaceView
        setRenderer(new HelloOpenGLES20Renderer());
    }
}

My surface class is as follows

import java.nio.ByteBuffer;
import java.nio.ByteOrder;
import java.nio.FloatBuffer;

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

import android.opengl.GLES20;
import android.opengl.GLSurfaceView;

public class HelloOpenGLES20Renderer implements GLSurfaceView.Renderer {

private FloatBuffer triangleVB;

private final String vertexShaderCode = 
                "attribute vec4 vPosition; \n" +
                "void main(){              \n" +
                " gl_Position = vPosition; \n" +
                "}                         \n";

private final String fragmentShaderCode = 
                "precision mediump float;  \n" +
                "void main(){              \n" +
                " gl_FragColor = vec4 (0.63671875, 0.76953125, 0.22265625, 1.0); \n" +
                "}                         \n";

private int mProgram;
            private int maPositionHandle;

public void onSurfaceCreated(GL10 unused, EGLConfig config) {

 Set the background frame color
        GLES20.glClearColor(0.5f, 0.5f, 0.5f, 1.0f);

 initialize the triangle vertex array
        initShapes();

int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexShaderCode);
        int fragmentShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentShaderCode);

mProgram = GLES20.glCreateProgram();              create empty OpenGL Program
        GLES20.glAttachShader(mProgram, vertexShader);    add the vertex shader to program
        GLES20.glAttachShader(mProgram, fragmentShader);  add the fragment shader to program
        GLES20.glLinkProgram(mProgram);                   creates OpenGL program executables

 get handle to the vertex shader's vPosition member
        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "vPosition");
    }

public void onDrawFrame(GL10 unused) {

 Redraw background color
        GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT | GLES20.GL_DEPTH_BUFFER_BIT);
         Add program to OpenGL environment
        GLES20.glUseProgram(mProgram);

 Prepare the triangle data
        GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false, 12, triangleVB);
        GLES20.glEnableVertexAttribArray(maPositionHandle);

 Draw the triangle
        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);
    }

public void onSurfaceChanged(GL10 unused, int width, int height) {
        GLES20.glViewport(0, 0, width, height);
    }

private void initShapes(){

float triangleCoords[] = {
             X, Y, Z
            -0.5f, -0.25f, 0,
             0.5f, -0.25f, 0,
             0.0f,  0.559016994f, 0
        }; 

 initialize vertex Buffer for triangle  
        ByteBuffer vbb = ByteBuffer.allocateDirect(
                 (# of coordinate values * 4 bytes per float)
                triangleCoords.length * 4); 
        vbb.order(ByteOrder.nativeOrder());// use the device hardware's native byte order
        triangleVB = vbb.asFloatBuffer();   create a floating point buffer from the ByteBuffer
        triangleVB.put(triangleCoords);     add the coordinates to the FloatBuffer
        triangleVB.position(0);             set the buffer to read the first coordinate

}

private int loadShader(int type, String shaderCode){

 create a vertex shader type (GLES20.GL_VERTEX_SHADER)
         or a fragment shader type (GLES20.GL_FRAGMENT_SHADER)
        int shader = GLES20.glCreateShader(type); 

 add the source code to the shader and compile it
        GLES20.glShaderSource(shader, shaderCode);
        GLES20.glCompileShader(shader);

return shader;
    }

}

You receive this error because the device you are testing does not support OpenGL ES 2.0. You may be testing this on an emulator that does not support that version of OpenGL.

Just try to test it on a real device and you will find that it works.