Android Development Tutorials: Opengles Animation Example (Part I)

This example shows how to use opengles to create animation in android.

Algorithm:

1.) Create a new project by File-> New -> Android Project name it OpenglesAnimationExample1.

2.) Create and write following into StaticTriangleRenderer.java:

package com.example.OpenglesAnimationExample1;
import static android.opengl.GLES10.GL_CCW;

import static android.opengl.GLES10.GL_CLAMP_TO_EDGE;

import static android.opengl.GLES10.GL_COLOR_BUFFER_BIT;

import static android.opengl.GLES10.GL_DEPTH_BUFFER_BIT;

import static android.opengl.GLES10.GL_DEPTH_TEST;

import static android.opengl.GLES10.GL_DITHER;

import static android.opengl.GLES10.GL_FASTEST;

import static android.opengl.GLES10.GL_FLOAT;

import static android.opengl.GLES10.GL_LINEAR;

import static android.opengl.GLES10.GL_MODELVIEW;

import static android.opengl.GLES10.GL_MODULATE;

import static android.opengl.GLES10.GL_NEAREST;

import static android.opengl.GLES10.GL_PERSPECTIVE_CORRECTION_HINT;

import static android.opengl.GLES10.GL_PROJECTION;

import static android.opengl.GLES10.GL_REPEAT;

import static android.opengl.GLES10.GL_REPLACE;

import static android.opengl.GLES10.GL_SMOOTH;

import static android.opengl.GLES10.GL_TEXTURE0;

import static android.opengl.GLES10.GL_TEXTURE_2D;

import static android.opengl.GLES10.GL_TEXTURE_COORD_ARRAY;

import static android.opengl.GLES10.GL_TEXTURE_ENV;

import static android.opengl.GLES10.GL_TEXTURE_ENV_MODE;

import static android.opengl.GLES10.GL_TEXTURE_MAG_FILTER;

import static android.opengl.GLES10.GL_TEXTURE_MIN_FILTER;

import static android.opengl.GLES10.GL_TEXTURE_WRAP_S;

import static android.opengl.GLES10.GL_TEXTURE_WRAP_T;

import static android.opengl.GLES10.GL_TRIANGLE_STRIP;

import static android.opengl.GLES10.GL_UNSIGNED_SHORT;

import static android.opengl.GLES10.GL_VERTEX_ARRAY;

import static android.opengl.GLES10.glActiveTexture;

import static android.opengl.GLES10.glBindTexture;

import static android.opengl.GLES10.glClear;

import static android.opengl.GLES10.glClearColor;

import static android.opengl.GLES10.glDisable;

import static android.opengl.GLES10.glDrawElements;

import static android.opengl.GLES10.glEnable;

import static android.opengl.GLES10.glEnableClientState;

import static android.opengl.GLES10.glFrontFace;

import static android.opengl.GLES10.glFrustumf;

import static android.opengl.GLES10.glGenTextures;

import static android.opengl.GLES10.glHint;

import static android.opengl.GLES10.glLoadIdentity;

import static android.opengl.GLES10.glMatrixMode;

import static android.opengl.GLES10.glRotatef;

import static android.opengl.GLES10.glShadeModel;

import static android.opengl.GLES10.glTexCoordPointer;

import static android.opengl.GLES10.glTexEnvf;

import static android.opengl.GLES10.glTexEnvx;

import static android.opengl.GLES10.glTexParameterf;

import static android.opengl.GLES10.glTexParameterx;

import static android.opengl.GLES10.glVertexPointer;

import static android.opengl.GLES10.glViewport;

import java.io.IOException;

import java.io.InputStream;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import java.nio.ShortBuffer;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLSurfaceView;

import android.opengl.GLU;

import android.opengl.GLUtils;

import android.os.SystemClock;

public class StaticTriangleRenderer implements GLSurfaceView.Renderer{

    public interface TextureLoader {

        void load(GL10 gl);

    }

    public StaticTriangleRenderer(Context context) {

        init(context, new RobotTextureLoader());

    }

    public StaticTriangleRenderer(Context context, TextureLoader loader) {

        init(context, loader);

    }

    private void init(Context context, TextureLoader loader) {

        mContext = context;

        mTriangle = new Triangle();

        mTextureLoader = loader;

    }

    public void onSurfaceCreated(GL10 gl, EGLConfig config) {

        glDisable(GL_DITHER);

        glHint(GL_PERSPECTIVE_CORRECTION_HINT,

                GL_FASTEST);

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

        glShadeModel(GL_SMOOTH);

        glEnable(GL_DEPTH_TEST);

        glEnable(GL_TEXTURE_2D);

        int[] textures = new int[1];

        glGenTextures(1, textures, 0);

        mTextureID = textures[0];

        glBindTexture(GL_TEXTURE_2D, mTextureID);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER,

                GL_NEAREST);

        glTexParameterf(GL_TEXTURE_2D,

                GL_TEXTURE_MAG_FILTER,

                GL_LINEAR);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,

                GL_CLAMP_TO_EDGE);

        glTexParameterf(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,

                GL_CLAMP_TO_EDGE);

        glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,

                GL_REPLACE);

        mTextureLoader.load(gl);

    }

    public void onDrawFrame(GL10 gl) {

        glDisable(GL_DITHER);

        glTexEnvx(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE,

                GL_MODULATE);

        glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

        glMatrixMode(GL_MODELVIEW);

        glLoadIdentity();

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

        glEnableClientState(GL_VERTEX_ARRAY);

        glEnableClientState(GL_TEXTURE_COORD_ARRAY);

        glActiveTexture(GL_TEXTURE0);

        glBindTexture(GL_TEXTURE_2D, mTextureID);

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S,

                GL_REPEAT);

        glTexParameterx(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T,

                GL_REPEAT);

        long time = SystemClock.uptimeMillis() % 4000L;

        float angle = 0.090f * ((int) time);

        glRotatef(angle, 0, 0, 1.0f);

        mTriangle.draw(gl);

    }

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

        glViewport(0, 0, w, h);

        float ratio = (float) w / h;

        glMatrixMode(GL_PROJECTION);

        glLoadIdentity();

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

    }

    private Context mContext;

    private Triangle mTriangle;

    private int mTextureID;

    private TextureLoader mTextureLoader;

    private class RobotTextureLoader implements TextureLoader {

        public void load(GL10 gl) {

            InputStream is = mContext.getResources().openRawResource(

                    R.raw.robot);

            Bitmap bitmap;

            try {

                bitmap = BitmapFactory.decodeStream(is);

            } finally {

                try {

                    is.close();

                } catch (IOException e) {

                    // Ignore.

                }

            }

            GLUtils.texImage2D(GL_TEXTURE_2D, 0, bitmap, 0);

            bitmap.recycle();

        }

    }

    static class Triangle {

        public Triangle() {

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

            vbb.order(ByteOrder.nativeOrder());

            mFVertexBuffer = vbb.asFloatBuffer();

            ByteBuffer tbb = ByteBuffer.allocateDirect(VERTS * 2 * 4);

            tbb.order(ByteOrder.nativeOrder());

            mTexBuffer = tbb.asFloatBuffer();

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

            ibb.order(ByteOrder.nativeOrder());

            mIndexBuffer = ibb.asShortBuffer();

            float[] coords = {

                    -0.5f, -0.25f, 0,

                     0.5f, -0.25f, 0,

                     0.0f,  0.559016994f, 0

            };

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

                for(int j = 0; j < 3; j++) {

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

                }

            }

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

                for(int j = 0; j < 2; j++) {

                    mTexBuffer.put(coords[i*3+j] * 2.0f + 0.5f);

                }

            }

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

                mIndexBuffer.put((short) i);

            }

            mFVertexBuffer.position(0);

            mTexBuffer.position(0);

            mIndexBuffer.position(0);

        }

        public void draw(GL10 gl) {

            glFrontFace(GL_CCW);

            glVertexPointer(3, GL_FLOAT, 0, mFVertexBuffer);

            glEnable(GL_TEXTURE_2D);

            glTexCoordPointer(2, GL_FLOAT, 0, mTexBuffer);

            glDrawElements(GL_TRIANGLE_STRIP, VERTS,

                    GL_UNSIGNED_SHORT, mIndexBuffer);

        }

        private final static int VERTS = 3;

        private FloatBuffer mFVertexBuffer;

        private FloatBuffer mTexBuffer;

        private ShortBuffer mIndexBuffer;

    }

}

3.) Add android.pkm and robot.png files attached with this post to res/raw folder.
4.) Run for output.
Steps:
1.) Create a project named OpenglesAnimationExample1 and set the information as stated in the image.
Build Target: Android 4.0
Application Name: OpenglesAnimationExample1
Package Name: com. example. OpenglesAnimationExample1
Activity Name: OpenglesAnimationExample1Activity
Min SDK Version: 14

2.) Open OpenglesAnimationExample1Activity.java file and write following code there:

package com.example.OpenglesAnimationExample1;
import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.InputStream;

import java.nio.Buffer;

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import javax.microedition.khronos.opengles.GL10;

import android.app.Activity;

import android.opengl.ETC1Util;

import android.opengl.GLES10;

import android.opengl.GLSurfaceView;

import android.os.Bundle;

import android.util.Log;

public class OpenglesAnimationExample1Activity extends Activity {

    private final static String TAG = "CompressedTextureActivity";

    private final static boolean TEST_CREATE_TEXTURE = false;

    private final static boolean USE_STREAM_IO = false;

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        mGLView = new GLSurfaceView(this);

        mGLView.setEGLConfigChooser(false);

        StaticTriangleRenderer.TextureLoader loader;

        if (TEST_CREATE_TEXTURE) {

            loader = new SyntheticCompressedTextureLoader();

        } else {

            loader = new CompressedTextureLoader();

        }

        mGLView.setRenderer(new StaticTriangleRenderer(this, loader));

        setContentView(mGLView);

    }

    @Override

    protected void onPause() {

        super.onPause();

        mGLView.onPause();

    }

    @Override

    protected void onResume() {

        super.onResume();

        mGLView.onResume();

    }

    private class CompressedTextureLoader implements StaticTriangleRenderer.TextureLoader {

        public void load(GL10 gl) {

            Log.w(TAG, "ETC1 texture support: " + ETC1Util.isETC1Supported());

            InputStream input = getResources().openRawResource(R.raw.androids);

            try {

                ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,

                        GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, input);

            } catch (IOException e) {

                Log.w(TAG, "Could not load texture: " + e);

            } finally {

                try {

                    input.close();

                } catch (IOException e) {

                }

            }

        }

    }

    private class SyntheticCompressedTextureLoader implements StaticTriangleRenderer.TextureLoader {

        public void load(GL10 gl) {

            int width = 128;

            int height = 128;

            Buffer image = createImage(width, height);

            ETC1Util.ETC1Texture etc1Texture = ETC1Util.compressTexture(image, width, height, 3, 3 * width);

            if (USE_STREAM_IO) {

                try {

                    ByteArrayOutputStream bos = new ByteArrayOutputStream();

                    ETC1Util.writeTexture(etc1Texture, bos);

                    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());

                    ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,

                            GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, bis);

                } catch (IOException e) {

                    Log.w(TAG, "Could not load texture: " + e);

                }

            } else {

                ETC1Util.loadTexture(GLES10.GL_TEXTURE_2D, 0, 0,

                        GLES10.GL_RGB, GLES10.GL_UNSIGNED_SHORT_5_6_5, etc1Texture);

            }

        }

        private Buffer createImage(int width, int height) {

            int stride = 3 * width;

            ByteBuffer image = ByteBuffer.allocateDirect(height * stride)

                .order(ByteOrder.nativeOrder());

            for (int t = 0; t < height; t++) {

                byte red = (byte)(255-2*t);

                byte green = (byte)(2*t);

                byte blue = 0;

                for (int x = 0; x < width; x++) {

                    int y = x ^ t;

                    image.position(stride*y+x*3);

                    image.put(red);

                    image.put(green);

                    image.put(blue);

                }

            }

            image.position(0);

            return image;

        }

    }

    private GLSurfaceView mGLView;

}