OpenGL ES 2.0 on Android 2.2

Android 2.2 ApiDemo에는 OpenGL ES 2.0을 이용하여 Textured Triangle을 회전시키는 예제가 들어있다.

그냥 막연하게 OpenGL ES 1.1을 가지고 뭔가를 해 보려고 했었는데, GLSurfaceView.Renderer interface method 들의 argument가 GL10으로 되어 있어, 그걸 GL11로 casting 해서 사용해 보려고도 했었는데 (당연히) 실패했다(하하^^;). 그래서, "아... OpenGL ES 2.0은 커녕 OpenGL ES 1.1도 사용하기 어렵구나..." 라고만 생각하고 있었는데, 바보 같은 생각 이었다. (역시 사람은 모르면 찾아보고 물어봐야 한다! -_-;)

GLSurfaceView는 하나의 Activity에서 하나의 instance만 사용이 가능하기 때문에, (아마도 OpenGL이 state machine 기반이기 때문이 아닐까 짐작) GLES11 또는 GLES20 class의 static method로 이용이 가능했던 것이다. GLES11 or GLES20 reference document만 차분히 확인 했어도 짐작할 수 있었던 내용인데, GLSurfaceView.Renderer interface method 들의 argument로 넘겨주는 GL10 instance에 낚여 버렸다. (javax.microedition.khronos.opengles.GLnx와 android.opengl.GLESnx의 차이는 또 다시 확인 해 봐야 할 사항이다. License 때문에 Java Micro Edition은 Android에서 빠졌다고 알고 있는데, 이건 왜 넣어 놓은걸까? 궁금!)

어쨌든, Android 2.2 이상에서 OpenGL ES 2.0을 이용하는 방법(순서?)를 ApiDemo를 기준으로 정리하면 다음과 같다.

[[[ Activity ]]]

/*

 * 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.example.android.apis.graphics;



import android.app.Activity;

import android.app.ActivityManager;

import android.content.Context;

import android.content.pm.ConfigurationInfo;

import android.opengl.GLSurfaceView;

import android.os.Bundle;



/**

 * This sample shows how to check for OpenGL ES 2.0 support at runtime, and then

 * use either OpenGL ES 1.0 or OpenGL ES 2.0, as appropriate.

 */

public class GLES20Activity extends Activity {

    @Override

    protected void onCreate(Bundle savedInstanceState) {

        super.onCreate(savedInstanceState);

        mGLSurfaceView = new GLSurfaceView(this);

        if (detectOpenGLES20()) {

            // Tell the surface view we want to create an OpenGL ES 2.0-compatible

            // context, and set an OpenGL ES 2.0-compatible renderer.

            mGLSurfaceView.setEGLContextClientVersion(2);

            mGLSurfaceView.setRenderer(new GLES20TriangleRenderer(this));

        } else {

            // Set an OpenGL ES 1.x-compatible renderer. In a real application

            // this renderer might approximate the same output as the 2.0 renderer.

            mGLSurfaceView.setRenderer(new TriangleRenderer(this));

        }

        setContentView(mGLSurfaceView);

    }



    private boolean detectOpenGLES20() {

        ActivityManager am =

            (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE);

        ConfigurationInfo info = am.getDeviceConfigurationInfo();

        return (info.reqGlEsVersion >= 0x20000);

    }



    @Override

    protected void onResume() {

        // Ideally a game should implement onResume() and onPause()

        // to take appropriate action when the activity looses focus

        super.onResume();

        mGLSurfaceView.onResume();

    }



    @Override

    protected void onPause() {

        // Ideally a game should implement onResume() and onPause()

        // to take appropriate action when the activity looses focus

        super.onPause();

        mGLSurfaceView.onPause();

    }



    private GLSurfaceView mGLSurfaceView;

}

1. GLSurfaceView instance를 생성
2. ActivityManager service에서 device configuration info(android.content.pm.ConfigurationInfo)를 획득하여 OpenGL ES 버전을 확인
3. (1)에서 생성한 GLSurfaceView가 사용할 EGL의 Version을 2(아마도 2.0?)로 설정
4. OpenGL ES 2.0으로 작성 된 Renderer instance를 (1)에서 생성한 GLSurfaceView의 renderer로 설정
5. 선택적으로 rendering overhead를 줄이기 위해, (1)에서 생성한 GLSurfaceView의 setRenderMode method를 호출하여 렌더링 모드를 RENDERMODE_WHEN_DIRTY로 설정할 수 있다. (기본은 RENDERMODE_CONTINUOSLY)

[[[ GLSurfaceView.Renderer ]]]

/*

 * 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.example.android.apis.graphics;



import java.io.IOException;

import java.io.InputStream;

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.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLES20;

import android.opengl.GLSurfaceView;

import android.opengl.GLUtils;

import android.opengl.Matrix;

import android.os.SystemClock;

import android.util.Log;



import com.example.android.apis.R;



class GLES20TriangleRenderer implements GLSurfaceView.Renderer {



    public GLES20TriangleRenderer(Context context) {

        mContext = context;

        mTriangleVertices = ByteBuffer.allocateDirect(mTriangleVerticesData.length

                * FLOAT_SIZE_BYTES).order(ByteOrder.nativeOrder()).asFloatBuffer();

        mTriangleVertices.put(mTriangleVerticesData).position(0);

    }



    public void onDrawFrame(GL10 glUnused) {

        // Ignore the passed-in GL10 interface, and use the GLES20

        // class's static methods instead.

        GLES20.glClearColor(0.0f, 0.0f, 1.0f, 1.0f);

        GLES20.glClear( GLES20.GL_DEPTH_BUFFER_BIT | GLES20.GL_COLOR_BUFFER_BIT);

        GLES20.glUseProgram(mProgram);

        checkGlError("glUseProgram");



        GLES20.glActiveTexture(GLES20.GL_TEXTURE0);

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureID);



        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_POS_OFFSET);

        GLES20.glVertexAttribPointer(maPositionHandle, 3, GLES20.GL_FLOAT, false,

                TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);

        checkGlError("glVertexAttribPointer maPosition");

        mTriangleVertices.position(TRIANGLE_VERTICES_DATA_UV_OFFSET);

        GLES20.glEnableVertexAttribArray(maPositionHandle);

        checkGlError("glEnableVertexAttribArray maPositionHandle");

        GLES20.glVertexAttribPointer(maTextureHandle, 2, GLES20.GL_FLOAT, false,

                TRIANGLE_VERTICES_DATA_STRIDE_BYTES, mTriangleVertices);

        checkGlError("glVertexAttribPointer maTextureHandle");

        GLES20.glEnableVertexAttribArray(maTextureHandle);

        checkGlError("glEnableVertexAttribArray maTextureHandle");



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

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

        Matrix.setRotateM(mMMatrix, 0, angle, 0, 0, 1.0f);

        Matrix.multiplyMM(mMVPMatrix, 0, mVMatrix, 0, mMMatrix, 0);

        Matrix.multiplyMM(mMVPMatrix, 0, mProjMatrix, 0, mMVPMatrix, 0);



        GLES20.glUniformMatrix4fv(muMVPMatrixHandle, 1, false, mMVPMatrix, 0);

        GLES20.glDrawArrays(GLES20.GL_TRIANGLES, 0, 3);

        checkGlError("glDrawArrays");

    }



    public void onSurfaceChanged(GL10 glUnused, int width, int height) {

        // Ignore the passed-in GL10 interface, and use the GLES20

        // class's static methods instead.

        GLES20.glViewport(0, 0, width, height);

        float ratio = (float) width / height;

        Matrix.frustumM(mProjMatrix, 0, -ratio, ratio, -1, 1, 3, 7);

    }



    public void onSurfaceCreated(GL10 glUnused, EGLConfig config) {

        // Ignore the passed-in GL10 interface, and use the GLES20

        // class's static methods instead.

        mProgram = createProgram(mVertexShader, mFragmentShader);

        if (mProgram == 0) {

            return;

        }

        maPositionHandle = GLES20.glGetAttribLocation(mProgram, "aPosition");

        checkGlError("glGetAttribLocation aPosition");

        if (maPositionHandle == -1) {

            throw new RuntimeException("Could not get attrib location for aPosition");

        }

        maTextureHandle = GLES20.glGetAttribLocation(mProgram, "aTextureCoord");

        checkGlError("glGetAttribLocation aTextureCoord");

        if (maTextureHandle == -1) {

            throw new RuntimeException("Could not get attrib location for aTextureCoord");

        }



        muMVPMatrixHandle = GLES20.glGetUniformLocation(mProgram, "uMVPMatrix");

        checkGlError("glGetUniformLocation uMVPMatrix");

        if (muMVPMatrixHandle == -1) {

            throw new RuntimeException("Could not get attrib location for uMVPMatrix");

        }



        /*

         * Create our texture. This has to be done each time the

         * surface is created.

         */



        int[] textures = new int[1];

        GLES20.glGenTextures(1, textures, 0);



        mTextureID = textures[0];

        GLES20.glBindTexture(GLES20.GL_TEXTURE_2D, mTextureID);



        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_MIN_FILTER,

                GLES20.GL_NEAREST);

        GLES20.glTexParameterf(GLES20.GL_TEXTURE_2D,

                GLES20.GL_TEXTURE_MAG_FILTER,

                GLES20.GL_LINEAR);



        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_S,

                GLES20.GL_REPEAT);

        GLES20.glTexParameteri(GLES20.GL_TEXTURE_2D, GLES20.GL_TEXTURE_WRAP_T,

                GLES20.GL_REPEAT);



        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(GLES20.GL_TEXTURE_2D, 0, bitmap, 0);

        bitmap.recycle();



        Matrix.setLookAtM(mVMatrix, 0, 0, 0, -5, 0f, 0f, 0f, 0f, 1.0f, 0.0f);

    }



    private int loadShader(int shaderType, String source) {

        int shader = GLES20.glCreateShader(shaderType);

        if (shader != 0) {

            GLES20.glShaderSource(shader, source);

            GLES20.glCompileShader(shader);

            int[] compiled = new int[1];

            GLES20.glGetShaderiv(shader, GLES20.GL_COMPILE_STATUS, compiled, 0);

            if (compiled[0] == 0) {

                Log.e(TAG, "Could not compile shader " + shaderType + ":");

                Log.e(TAG, GLES20.glGetShaderInfoLog(shader));

                GLES20.glDeleteShader(shader);

                shader = 0;

            }

        }

        return shader;

    }



    private int createProgram(String vertexSource, String fragmentSource) {

        int vertexShader = loadShader(GLES20.GL_VERTEX_SHADER, vertexSource);

        if (vertexShader == 0) {

            return 0;

        }



        int pixelShader = loadShader(GLES20.GL_FRAGMENT_SHADER, fragmentSource);

        if (pixelShader == 0) {

            return 0;

        }



        int program = GLES20.glCreateProgram();

        if (program != 0) {

            GLES20.glAttachShader(program, vertexShader);

            checkGlError("glAttachShader");

            GLES20.glAttachShader(program, pixelShader);

            checkGlError("glAttachShader");

            GLES20.glLinkProgram(program);

            int[] linkStatus = new int[1];

            GLES20.glGetProgramiv(program, GLES20.GL_LINK_STATUS, linkStatus, 0);

            if (linkStatus[0] != GLES20.GL_TRUE) {

                Log.e(TAG, "Could not link program: ");

                Log.e(TAG, GLES20.glGetProgramInfoLog(program));

                GLES20.glDeleteProgram(program);

                program = 0;

            }

        }

        return program;

    }



    private void checkGlError(String op) {

        int error;

        while ((error = GLES20.glGetError()) != GLES20.GL_NO_ERROR) {

            Log.e(TAG, op + ": glError " + error);

            throw new RuntimeException(op + ": glError " + error);

        }

    }



    private static final int FLOAT_SIZE_BYTES = 4;

    private static final int TRIANGLE_VERTICES_DATA_STRIDE_BYTES = 5 * FLOAT_SIZE_BYTES;

    private static final int TRIANGLE_VERTICES_DATA_POS_OFFSET = 0;

    private static final int TRIANGLE_VERTICES_DATA_UV_OFFSET = 3;

    private final float[] mTriangleVerticesData = {

            // X, Y, Z, U, V

            -1.0f, -0.5f, 0, -0.5f, 0.0f,

            1.0f, -0.5f, 0, 1.5f, -0.0f,

            0.0f,  1.11803399f, 0, 0.5f,  1.61803399f };



    private FloatBuffer mTriangleVertices;



    private final String mVertexShader =

        "uniform mat4 uMVPMatrix;\n" +

        "attribute vec4 aPosition;\n" +

        "attribute vec2 aTextureCoord;\n" +

        "varying vec2 vTextureCoord;\n" +

        "void main() {\n" +

        "  gl_Position = uMVPMatrix * aPosition;\n" +

        "  vTextureCoord = aTextureCoord;\n" +

        "}\n";



    private final String mFragmentShader =

        "precision mediump float;\n" +

        "varying vec2 vTextureCoord;\n" +

        "uniform sampler2D sTexture;\n" +

        "void main() {\n" +

        "  gl_FragColor = texture2D(sTexture, vTextureCoord);\n" +

        "}\n";



    private float[] mMVPMatrix = new float[16];

    private float[] mProjMatrix = new float[16];

    private float[] mMMatrix = new float[16];

    private float[] mVMatrix = new float[16];



    private int mProgram;

    private int mTextureID;

    private int muMVPMatrixHandle;

    private int maPositionHandle;

    private int maTextureHandle;



    private Context mContext;

    private static String TAG = "GLES20TriangleRenderer";

}

(onSurfaceCreated)
1. Vertex Shader를 생성하고, Vertext Shader 코드를 로드 & 컴파일
    glCreateShader(), glShaderSource(), glCompileShader()
2. Fragment Shader를 생성하고, Fragment Shader  코드를 로드 & 컴파일
    glCreateShader(), glShaderSource(), glCompileShader()
3. Program을 생성 (Vertext Shader 및 Fragment Shader를 묶는 단위)
3-1. Vertext Shader를 Program에 attach glCreateProgram()
3-2. Fragment Shader를 Program에 attach glAttachShader()
3-3. Vertext Shader와 Fragment Shader가 추가된 Program을 링크 glLinkProgram()
4. Program으로부터 attribute와 uniform을 참조할 수 있는 handle을 획득
    glGetAttribLocation(), glGetUniformLocation()
5. Rendering에 사용 될 Texture를 준비
5-1. Texture object 생성
5-2. 생성된 Texture의 ID를 GL_TEXTURE_2D로 바인딩
5-3. GL_TEXTURE_2D의 옵션(속성)을 설정
5-4. Bitmap data를 GL_TEXTURE_2D로 전송
6. Matrix class를 이용해 View Matrix를 초기화 (Camera 설정이라고 생각하면 될 듯)
    Matrix.setLootAtM()

(onSurfaceChanged)
7. View 영역(View port)를 설정 glViewport()
8. Matrix class를 이용해 Projection Matrix를 초기화 Matrix.frustumM()

(onDrawFrame)
9. Clear 색상 설정 glClearColor()
10. Depth buffer와 Color buffer를 초기화 glClear()
11. 사용할 Program을 지정 glUseProgram()
12. Texture를 활성화 하고, (5-4)에서 전송 해 둔 Texture ID와 연결
13. Vertex 좌표가 저장된 buffer의 포인터를 attribute로 설정 glVertexAttribPointer()
     - glVertexAttribPointer() 사용 시 주의할 점은, 5th argument인 stride는 byte 기준이라는 것!
     - 즉, float 형 x, y, z 세 개씩 건너 뛰어야 할 경우, stride 값은 3 * float 변수의 byte 크기(4) = 12
        (stride 값을 3으로 주고, 안보여서 한참 삽질 했네-_-;)
14. Vertex attribute array를 활성화 glEnableVertexAttribArray()
15. Texture 좌표가 저장된 buffer의 포인터를 attribute로 설정
16. Model Matrix 설정(여기서는 회전) Matrix.setRotateM()
17. MVP Matrix를 계산(MVPMatrix = mProjMatrix * VMatrix * MMatrix) Matrix.multiplyMM()
18. MVP Matrix를 uniform으로 설정 glUniformMatrix4fv()
19. 삼각형을 출력 glDrawArrays()