Introduction to OpenGL in Android
OpenGL in Android is a graphics library that is used for 2D and 3D graphics development in Android applications. OpenGL provides cross-platform APIs. It processes high-performance data transfer between CPU and GPU. OpenGL supports the android native development kit(NDK) for graphics features development. There are three classes used with OpenGL such as GLSurfVaceiew, Renderer and GLSurfaceView. There are several OpenGL objects associated with the Android operating system. It creates a rendering pipeline in the six stages such as Per-Vertex Operation, Primitive Assembly, Primitive Processing, Rasterization, Fragment Processing, and Per-Fragment Operation. OpenGL implemented using Programming skills along with mathematical competencies such as vectors and matrices.
GLSurfaceView
You can draw and manipulate objects in this view. It’s easy to use this class as you can create an object of GLSurfaceView and add a Renderer to it. You can capture touch screen events by extending the GLSurfaceView class to implement the touch listeners.
GLSurfaceView.Renderer
The GLSurfaceView.The renderer interface contains methods that are required for drawing graphics in a GLSurfaceView. The implementation of this interface should be provided as a separate class attached to the GLSurfaceView instance using GLSurfaceView.setRenderer().
You need to implement the following methods for GLSurfaceView.Renderer interface implementation:
- onSurfaceCreated(): This method is called during the creation of the GLSurfaceView.
- onDrawFrame(): This method is called during each redraw of the GLSurfaceView.
- onSurfaceChanged(): This method is called when the GLSurfaceView geometry changes(size, orientation etc).
How does OpenGL in Android works?
There exist several types of OpenGL Objects. For example, a Vertex Buffer Object can store vertices of a character. The second example is Texture that can store image data.
Data such as vertices, normals, and UV coordinates which represent the characteristics of mesh, are loaded into a Vertex Buffer Object and then sent to the GPU for processing. Once it is in the GPU, these data would go through what is known as the OpenGL Rendering Pipeline.
The main tasks for which Rendering Pipeline is responsible are the conversion of the vertices to the right coordinate system, assembling of vertices of a character, application of color or texture and displaying of the character on the default framebuffer, which is the screen.
The rendering pipeline process of OpenGL in Android consists of six stages as below :
- Per-Vertex Operation
- Primitive Assembly
- Primitive Processing
- Rasterization
- Fragment Processing
- Per-Fragment Operation
Per-Vertex Operation
The first and foremost step to render an image is geometry data that has to be converted from one coordinate system into another coordinate system.
Primitive Assembly
The vertices are collected into pairs of 2, 3and more in this particular step and the primitive is assembled, for example, a triangle.
Primitive Processing
When the primitives have been assembled, they are tested to check if they are falling within a View-Volume. In case they do not pass this particular test, they would get ignored in further steps. This test is known as Clipping.
Rasterization
Then Primitives are broken down into chunks of smaller units and corresponding to that of pixels in the framebuffer. Each of these smaller units is then known as Fragments.
Fragment Processing
When primitive has been rasterized, then color or texture is applied to the geometry.
Per-Fragment Operation
Lastly, the fragments are submitted to various tests such as :
- Pixel Ownership test
- Scissor test
- Alpha test
- Stencil test
- Depth test
From these six stages, two stages are being controlled by programs which are called Shaders.
Shader, in short, is a small program that is developed by you only that lives in the GPU. There is a special graphics language known as OpenGL Shading Language(GLSL) in which a shader is written. The two important stages in the OpenGL pipeline where a shader takes place are called “Per-Vertex Processing” and “Per-Fragment Processing” stages.
The shader that is processed in the “Per-Vertex” stage is known as Vertex Shader. The shader that is processed in the “Per-Fragment” stage is known as Fragment Shader. The ultimate and basic goal of the vertex shader is to give the final transformation of vertices of the character to the rendering pipeline, whereas the goal of the fragment shader is to give the coloring and texture data to each of the headings of pixel to the framebuffer.
When data is passed through the OpenGL Rendering Pipeline, then either the 3D or 2D model will appear on the screen of your device.
GL Program
Following is the GL program:
Advice for OpenGL in Android
In case you are a beginner in OpenGL programmer, then some of these points below might not have been yet encountered by you. Below are some guidelines for you to take care of while using OpenGL in Android. They are common mistakes. So always keep these in mind.
- Improperly Scaling of Normals for Lighting
- Poor Tessellation Hurts Lighting
- Always Remember Your Matrix Mode
- Overflowing of the Projection Matrix Stack
- Not Setting All the Mipmap Levels
- Reading Back Luminance Pixels
Pre-requisites for OpenGL in Android
Below are the prerequisite required for OpenGL in Android.
Software skills
- C that is, programming language.
- C++ knowledge isn’t necessary but is helpful.
- Usage of various libraries that can be either Static or dynamic.
Mathematics
- Knowledge of Vectors in both 2D and 3D.
- Matrices
- Basic level maths concepts.
These are all the main and basic concepts that are needed to start with OpenGL. You might need to learn some more math concepts, but after you get to the intermediate level. But that totally depends upon you. You can pass over many things with the help of different libraries.
Conclusion
Therefore, OpenGL is a completely functional API that is primitive-level and allowing the programmer to effectively address and take advantage of graphics hardware. A large number of high-level libraries as well as applications use OpenGL because of its performance, programming ease, extensibility as well as widespread support.
Recommended Article
This has been a guide to OpenGL in Android. Here we have discussed the Process of working and the pre-requisites of OpenGL in Android. You can also go through our other suggested articles to learn more –
