OpenGL ES

Overview

OpenGL ES (Embedded Systems) is the traditional cross-platform 3D graphics API for mobile devices. Until the widespread adoption of Vulkan, it was the exclusive low-level rendering API for Android. Today, it remains heavily used for hardware-accelerated UI rendering (via HWUI) and numerous legacy applications.

OpenGL ES 3.2 Features

Modern Android devices support OpenGL ES 3.2, which brings desktop-class rendering features to mobile hardware:

• Compute Shaders: Allows the GPU to execute general-purpose computing tasks, such as image processing or physics simulations, outside the standard graphics pipeline.
• Geometry and Tessellation Shaders: Provides hardware-accelerated geometry generation and refinement directly on the GPU.
• Advanced Texture Compression: Support for ASTC (Adaptive Scalable Texture Compression), drastically reducing memory bandwidth for complex textures.

#version 320 es
// Example of an OpenGL ES 3.2 Compute Shader
layout(local_size_x = 16, local_size_y = 16) in;
layout(rgba8, binding = 0) uniform writeonly highp image2D destTex;

void main() {
    ivec2 storePos = ivec2(gl_GlobalInvocationID.xy);
    vec4 color = vec4(1.0, 0.0, 0.0, 1.0); // Red pixel
    imageStore(destTex, storePos, color);
}

Shader Compilation in Android

In OpenGL ES, shaders are provided by the application as high-level text (GLSL). The GPU driver must compile this text into hardware-specific machine code at runtime.

1. glCreateShader() creates a shader object.
2. glShaderSource() loads the GLSL string.
3. glCompileShader() compiles it into intermediate representation.
4. glLinkProgram() links vertex and fragment shaders into an executable program.

This runtime compilation is historically a major source of "jank" (stuttering) in Android games, as compiling a complex shader during gameplay blocks the rendering thread.

Shader Caches

To mitigate the performance hit of runtime shader compilation, Android implements robust shader caching mechanisms.

When a shader is compiled for the first time, the driver saves the resulting binary machine code to disk. On subsequent runs, glLinkProgram() can bypass the compilation step and load the binary directly from the cache.

Android stores these caches in the application's private data directory. Furthermore, the Google Play Store can distribute pre-compiled shader caches alongside the APK, allowing games to run smoothly from the very first launch.

GLES Debugging with adb

Debugging OpenGL ES applications requires specialized tools. The Android GPU Inspector (AGI) is the modern standard, but adb provides several low-level properties to trace graphics commands.

You can force GLES error checking or trace GLES calls by setting system properties:

# Enable GLES tracing (requires a debuggable app)
adb shell setprop debug.egl.trace GLES
# Force screen updates to flash (helps identify overdraw)
adb shell setprop debug.hwui.overdraw show

These tools are essential for identifying inefficient rendering loops, redundant state changes, or unoptimized shaders in Android applications.