Sunday, October 6, 2013

21 STEPS FOR EMPLOYING OPENGL ES IN ANDROID





STEP 1
In the Activity declare a GLSurfaceView variable; for example:
private GLSurfaceView glSurfaceView;

STEP 2
In the onCreate event of the Activity set the GLSurfaceView variable, set OpenGL its version, and then set its renderer:
            glSurfaceView = new GLSurfaceView(this);
    
glSurfaceView.setEGLContextClientVersion(2);
    
glSurfaceView.setRenderer(new CubeRenderer(this));

STEP 3
In the Renderer, declare a Context variable:
            private final Context context;

STEP 4
In the constructor of the renderer, set the context:
            this.context = context;

STEP 5
Create a ByteBuffer object, and put the data provided for all the vertices in it:
            private final FloatBuffer vertexData;
     vertexData = ByteBuffer.allocateDirect(data.length * BYTES_PER_FLOAT)
                                    .order(ByteOrder.nativeOrder()).asFloatBuffer();
     vertexData.put(data);

STEP 6
In the onSurfaceCreated event of the Renderer, set:
     glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
     glEnable(GL_BLEND);
     glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);

STEP 7
Read the source of shaders:
     String vertexShaderSource = TextResourceReader
.readTextFileFromResource(context, R.raw.simple_vertex_shader);

     String fragmentShaderSource = TextResourceReader
                     .readTextFileFromResource(context, R.raw.simple_fragment_shader);

STEP 8
Compile the shader sources:
     int vertexShader = ShaderHelper.compileVertexShader(vertexShaderSource);

     int fragmentShader = ShaderHelper.compileFragmentShader(fragmentShaderSource);

STEP 9
Link the compiled code to create a Program:
            private int program;
     program = ShaderHelper.linkProgram(vertexShader, fragmentShader);

STEP 10
Ask OpenGL to use the program:
            glUseProgram(program);

STEP 11
Get the Uniform, Attribute, and Color positions from OpenGL:
     uMatrixLocation = glGetUniformLocation(program, U_MATRIX);
aPositionLocation = glGetAttribLocation(program, A_POSITION);
     aColorLocation = glGetAttribLocation(program, A_COLOR);

STEP 12
Set the Model matrix as unit, and  then, if it is required rotate it:
           setIdentityM(modelMatrix, 0);
          
           rotateM(modelMatrix, 0, -45f, 1f, 0f, 0f);


STEP 13
Set the Projection matrix:
MatrixHelper.perspectiveM(projectionMatrix, 45, (float) width / (float) height, 1f, 10f);

STEP 14
Set the View matrix:
setLookAtM(viewMatrix, 0, 0f, 1.2f, 2.2f, 0f, 0f, 0f, 0f, 1f, 0f);

STEP 15
Set the View Projection matrix:
multiplyMM(viewProjectionMatrix, 0, projectionMatrix, 0, viewMatrix, 0);

STEP 16
Set the Model View Projection matrix:
multiplyMM(modelViewProjectionMatrix, 0, viewProjectionMatrix, 0, modelMatrix, 0);

STEP 17
Set the Uniform Matrix for Location using the Model View Projection matrix:
glUniformMatrix4fv(uMatrixLocation, 1, false, modelViewProjectionMatrix, 0);

STEP 18
Bind data to the Position location, and enable it:
vertexData.position(0);
glVertexAttribPointer(aPositionLocation, POSITION_COMPONENT_COUNT,GL_FLOAT, false, STRIDE,
                                                                  vertexData);

     glEnableVertexAttribArray(aPositionLocation);

STEP 19
Bind data to the Color location, and enable it:
     vertexData.position(POSITION_COMPONENT_COUNT);
     glVertexAttribPointer(aColorLocation, COLOR_COMPONENT_COUNT, GL_FLOAT,     false, STRIDE,
                                                                     vertexData);

     glEnableVertexAttribArray(aColorLocation);

STEP 20
In the onDrawFrame event of the Renderer, clear the rendering surface:
glClear(GL_COLOR_BUFFER_BIT);

STEP 21
In the onDrawFrame event of the Renderer, draw all the arrays:
glDrawArrays(GL_TRIANGLES, 0, 18);