Interfacing OpenGL ES with Android

Using GLSurfaceView and Related Classes

Implement the Renderer interface.

Provide the Camera settings needed for your drawing in the implementation of the renderer.

Provide the drawing code in the onDrawFrame method of the implementation.

Construct a GLSurfaceView.

Set the renderer implemented in steps 1 to 3 in the GLSurfaceView.

Indicate whether you want animation or not to the GLSurfaceView.

Set the GLSurfaceView in an Activity as the content view. You can also use this view wherever you can use a regular view.

Let's start with how to implement the renderer interface.

Implementing the Renderer

public static interface GLSurfaceView.Renderer

{

void onDrawFrame(GL10 gl);

void onSurfaceCreated(GL10 gl, EGLConfig config);

}

The main drawing happens in the onDrawFrame() method. Whenever a new surface is created for this view, the onSurfaceCreated() method is called. We can call a number of OpenGL APIs such as dithering, depth control, or any others that can be called outside of the immediate onDrawFrame() method.

Even in the onDrawFrame() method there are lot of things that may be common for our specific drawing context. We can take advantage of this commonality and abstract these methods in another level of abstraction called an AbstractRenderer, which will have only one method that is left unimplemented called draw().

Listing 20–9 shows the code for the AbstractRenderer.

Listing 20–9. The AbstractRenderer

//filename: AbstractRenderer.java

import android.opengl.*;

//…Use Eclipse to resolve other imports

public abstract class AbstractRenderer

implements android.opengl.GLSurfaceView.Renderer

{

public void onSurfaceCreated(GL10 gl, EGLConfig eglConfig) {

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT,

GL10.GL_FASTEST);

gl.glClearColor(.5f, .5f, .5f, 1);

gl.glShadeModel(GL10.GL_SMOOTH);

gl.glEnable(GL10.GL_DEPTH_TEST);

}

public void onSurfaceChanged(GL10 gl, int w, int h) {

float ratio = (float) w / h;

gl.glMatrixMode(GL10.GL_PROJECTION);

gl.glLoadIdentity();

gl.glFrustumf(-ratio, ratio, -1, 1, 3, 7);

}

public void onDrawFrame(GL10 gl)

gl.glDisable(GL10.GL_DITHER);

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

gl.glMatrixMode(GL10.GL_MODELVIEW);

gl.glLoadIdentity();

GLU.gluLookAt(gl, 0, 0, -5, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

draw(gl);

}

protected abstract void draw(GL10 gl);

Having this abstract class is very useful, as it allows us to focus on just the drawing methods. We’ll use this class to create a SimpleTriangleRenderer class; Listing 20–10 shows the source code.

//filename: SimpleTriangleRenderer.java

public class SimpleTriangleRenderer extends AbstractRenderer

{

//Number of points or vertices we want to use

//A raw native buffer to hold the point coordinates

private FloatBuffer mFVertexBuffer;

//A raw native buffer to hold indices

//allowing a reuse of points.

private ShortBuffer mIndexBuffer;

public SimpleTriangleRenderer(Context context)

{

ByteBuffer vbb = ByteBuffer.allocateDirect(VERTS * 3 * 4);

mFVertexBuffer = vbb.asFloatBuffer();

ByteBuffer ibb = ByteBuffer.allocateDirect(VERTS * 2);

ibb.order(ByteOrder.nativeOrder());

mIndexBuffer = ibb.asShortBuffer();

float[] coords = {

-0.5f, -0.5f, 0, // (x1,y1,z1)

0.5f, -0.5f, 0,

0.0f, 0.5f, 0

};

for (int i = 0; i < VERTS; i++) {

mFVertexBuffer.put(coords[i*3+j]);

}

}

short[] myIndecesArray = {0,1,2};

{

mIndexBuffer.put(myIndecesArray[i]);

mFVertexBuffer.position(0);

mIndexBuffer.position(0);

}

//overriden method

{

gl.glColor4f(1.0f, 0, 0, 0.5f);

gl.glDrawElements(GL10.GL_TRIANGLES, VERTS,

GL10.GL_UNSIGNED_SHORT, mIndexBuffer);

}

}

According to our research, the java.nio package allocates memory space outside of the Java heap that can be directly used by such systems as OpenGL, File I/O, etc. The nio buffers are actually Java objects that eventually point to the native buffer. These nio objects are garbage collected. When they are garbage collected, they go ahead and delete the native memory. Java programs don’t have to do anything special to free the memory.

However, the gc won’t get fired unless memory is needed in the Java heap. This means you can run out of native memory and gc may not realize it. The Internet offers many examples on this subject where an out of memory exception will trigger a gc and then it’s possible to inquire if memory is now available due to gc having been invoked.

Under ordinary circumstances—and this is important for OpenGL—you can allocate the native buffers and not worry about releasing allocated memory explicitly because that is done by the gc.

Now that we have a sample renderer, let's see how we can supply this renderer to a GLSurfaceView and have it show up in an Activity.