OpenGL ES: apa itu, arsitektur dan penerapan

Apa itu OpenGL ES?

OpenGL ES (Open Graphics Library for Embedded Systems) — adalah subset dari API OpenGL desktop, yang diadaptasi untuk perangkat mobile, konsol game, dan sistem tertanam. Spesifikasi dikembangkan oleh konsorsium Khronos Group dan tersedia gratis untuk semua produsen. Tidak seperti OpenGL desktop, OpenGL ES menghapus fungsi usang dari pipeline tetap, hanya menyisakan pipeline shader yang dapat diprogram — ini mengurangi konsumsi daya dan menyederhanakan driver.

Bidang aplikasi utama OpenGL ES — rendering grafis waktu nyata. API ini digunakan dalam game mobile (Unity, Unreal Engine), aplikasi navigasi, solusi AR berbasis ARCore dan ARKit, serta dalam antarmuka sistem Android dan iOS. Menurut data StatCounter, 2026, pangsa perangkat dengan dukungan OpenGL ES 3.0+ melebihi 92% di antara smartphone aktif.

Keunggulan utama OpenGL ES — kemampuannya lintas platform. Aplikasi yang sama yang ditulis dalam OpenGL ES dapat berjalan di Android, iOS, Linux, dan Windows dengan perubahan minimal. Ini menjadikan API pilihan optimal untuk proyek yang menargetkan banyak platform tanpa menulis ulang mesin grafis.

Pipeline tetap vs dapat diprogram

Versi awal OpenGL (sebelum 2.0) menggunakan pipeline tetap — serangkaian tahap pemrosesan vertex dan piksel yang telah ditentukan. Pengembang hanya dapat mengonfigurasi parameter: posisi sumber cahaya, properti material, matriks transformasi. Pipeline yang dapat diprogram, diperkenalkan di OpenGL ES 2.0, menggantikan tahap tetap dengan shader — program kecil yang dijalankan di GPU. Ini memberi pengembang kendali penuh atas tampilan geometri.

Transisi ke pipeline yang dapat diprogram menjadi revolusi untuk grafis mobile. Pengembang mendapat kemampuan untuk mengimplementasikan efek kompleks: PBR (Physically Based Rendering), bayangan dinamis, pasca-pemrosesan, dan HDR. Pipeline tetap membutuhkan lebih sedikit kode, tetapi tidak memungkinkan pembuatan gaya visual yang unik. Game mobile modern sepenuhnya bekerja pada pipeline yang dapat diprogram.

Arsitektur OpenGL ES: pipeline rendering

Pipeline grafis OpenGL ES terdiri dari beberapa tahap berurutan, yang masing-masing mengubah data masukan dalam perjalanan dari vertex ke piksel di layar. Memahami arsitektur pipeline sangat penting untuk mengoptimalkan kinerja rendering pada perangkat mobile dengan anggaran daya dan panas yang terbatas.

Tahap pertama — vertex shader — memproses setiap vertex secara independen. Pada tahap ini, transformasi diterapkan: perpindahan dari ruang lokal model ke ruang dunia, kemudian ke ruang kamera, dan akhirnya ke ruang klip (clip space). Transformasi didefinisikan melalui matriks uniform MVP (Model-View-Projection), yang diperbarui setiap frame saat kamera atau objek bergerak.

Setelah perakitan primitif (titik, garis, segitiga), rasterisasi dilakukan — proses menentukan piksel layar mana yang dicakup oleh setiap primitif. Rasterizer menghasilkan fragmen — piksel potensial dengan atribut yang diinterpolasi (warna, normal, koordinat UV). Jumlah fragmen secara langsung tergantung pada resolusi layar dan luas proyeksi primitif.

Fragment shader dijalankan untuk setiap fragmen yang dihasilkan. Ini menghitung warna akhir piksel dengan mempertimbangkan tekstur, sumber cahaya, dan material. Pada keluaran fragment shader, serangkaian tes per-fragment dilakukan: depth test menentukan apakah fragmen terlihat; stencil test membatasi rendering berdasarkan masker; blending mencampur warna fragmen dengan warna yang sudah ditulis di buffer bingkai.

Status konteks OpenGL ES

OpenGL ES bekerja sebagai mesin status (state machine): semua pengaturan — shader saat ini, tekstur yang terikat, tes yang diaktifkan — disimpan dalam status global konteks. Perubahan status melalui glEnable, glBindTexture, atau glUseProgram mempengaruhi semua perintah menggambar berikutnya. Setiap pergantian status menyebabkan overhead di driver, oleh karena itu pengelompokan panggilan draw berdasarkan status adalah teknik optimasi utama.

Versi OpenGL ES dan kemampuannya

OpenGL ES 1.0 dan 1.1 (dirilis pada 2003–2004) didasarkan pada pipeline tetap. Mereka mendukung transformasi, tekstur, pencahayaan, dan blending, tetapi tidak mengizinkan pemrograman shader. API digunakan di ponsel awal dan perangkat berbasis Symbian dan Windows Mobile. Saat ini versi ini dianggap usang — perangkat modern tidak mendukungnya.

OpenGL ES 2.0 (2007) memperkenalkan pipeline yang dapat diprogram dengan vertex dan fragment shader dalam bahasa GLSL ES. Versi ini menjadi standar untuk Android 2.2+ dan iOS 5+ dan didukung oleh sebagian besar perangkat hingga hari ini. OpenGL ES 2.0 — versi minimum yang diperlukan untuk menjalankan Unity, Unreal Engine, dan Cocos2d-x di platform mobile.

OpenGL ES 3.0 (2012) menambahkan beberapa kemampuan kritis: beberapa target rendering (MRT), transform feedback, instancing, tekstur format arbitrer melalui ETC2/EAC. Kinerja rendering meningkat 30–50% dibandingkan versi 2.0 karena pengurangan jumlah panggilan draw. OpenGL ES 3.1 (2014) memperkenalkan compute shader dan operasi atomik dengan buffer — ini memungkinkan eksekusi di GPU tidak hanya tugas grafis tetapi juga tugas komputasi (pasca-pemrosesan, simulasi kain, perhitungan fisika).

OpenGL ES 3.2 (2015) — versi terakhir dari spesifikasi — menambahkan tessellation dan geometry shader, serta serangkaian tekstur float dan mode blend yang diperluas. Meskipun Vulkan yang lebih modern dirilis pada 2016, OpenGL ES 3.2 tetap menjadi API yang relevan berkat basis kode yang sangat besar dan kesederhanaan porting aplikasi antar platform.

Shader dalam OpenGL ES: GLSL dan pipeline yang dapat diprogram

GLSL ES (OpenGL Shading Language for Embedded Systems) — bahasa pemrograman shader berdasarkan sintaks C dengan tipe tambahan untuk bekerja dengan vektor dan matriks. Setiap shader adalah program yang dikompilasi ke kode mesin GPU pada tahap inisialisasi aplikasi. Tidak seperti kode CPU, shader dijalankan secara massal-paralel: ribuan vertex atau fragmen diproses secara bersamaan.

Vertex shader

Vertex shader memproses setiap vertex dari mesh. Tugas utamanya adalah menghitung posisi akhir vertex di clip space dengan mengalikan posisi masukan dengan matriks MVP. Selain itu, vertex shader dapat menghitung normal, koordinat UV, warna, dan meneruskannya ke fragment shader melalui variabel varying. Setiap panggilan vertex shader bekerja secara independen, memungkinkan GPU memproses jutaan vertex per frame.

// Vertex shader sederhana untuk OpenGL ES 3.0
#version 300 es
layout(location = 0) in vec4 a_position;
layout(location = 1) in vec3 a_normal;
layout(location = 2) in vec2 a_texCoord;

uniform mat4 u_mvpMatrix;

out vec3 v_normal;
out vec2 v_texCoord;

void main() {
    gl_Position = u_mvpMatrix * a_position;
    v_normal = mat3(u_mvpMatrix) * a_normal;
    v_texCoord = a_texCoord;
}

Fragment shader

Fragment shader menentukan warna setiap piksel di layar. Ini menerima nilai varying yang diinterpolasi dari vertex shader, memilih texel dari tekstur yang terikat, dan menerapkan pencahayaan. Untuk pencahayaan yang benar, digunakan model Phong atau Blinn-Phong dengan perhitungan komponen diffuse, specular, dan ambient. Setiap panggilan fragment shader sesuai dengan satu piksel, sehingga jumlah total panggilan sama dengan luas proyeksi objek di layar.

// Fragment shader sederhana dengan tekstur dan pencahayaan
#version 300 es
precision mediump float;

in vec3 v_normal;
in vec2 v_texCoord;

uniform sampler2D u_texture;
uniform vec3 u_lightDir;

out vec4 fragColor;

void main() {
    vec4 texel = texture(u_texture, v_texCoord);
    vec3 normal = normalize(v_normal);
    float diffuse = max(dot(normal, u_lightDir), 0.0);
    fragColor = vec4(texel.rgb * diffuse, texel.a);
}

Dalam contoh di atas, fragment shader memilih texel dari tekstur 2D berdasarkan koordinat UV, menghitung pencahayaan diffuse sebagai produk skalar normal dan arah cahaya, dan mengalikan warna texel dengan intensitas pencahayaan. Mediump — presisi yang direkomendasikan untuk fragment shader di GPU mobile: memberikan kualitas yang cukup dengan konsumsi daya minimal.

Memulai dengan OpenGL ES di proyek mobile

Untuk bekerja dengan OpenGL ES di Android, perlu membuat konteks EGL — permukaan tempat grafis akan ditampilkan. Di iOS, lapisan mirip EGL yang disebut EAGL digunakan, yang disediakan oleh framework GLKit. Dalam kedua kasus, proses inisialisasi mencakup pembuatan permukaan jendela, konfigurasi atribut konteks, dan pengikatan ke thread rendering saat ini.

// Inisialisasi OpenGL ES 3.0 di Android
class MyGLRenderer : GLSurfaceView.Renderer {

    private val vertexShaderCode = "#version 300 es\n..."
    private val fragmentShaderCode = "#version 300 es\n..."

    override fun onSurfaceCreated(gl: GL10?, config: EGLConfig?) {
        GLES30.glClearColor(0.1f, 0.1f, 0.2f, 1.0f)
        GLES30.glEnable(GLES30.GL_DEPTH_TEST)
    }

    override fun onDrawFrame(gl: GL10?) {
        GLES30.glClear(GLES30.GL_COLOR_BUFFER_BIT or GLES30.GL_DEPTH_BUFFER_BIT)
        // bind VBO, set uniforms, draw elements
    }

    override fun onSurfaceChanged(gl: GL10?, width: Int, height: Int) {
        GLES30.glViewport(0, 0, width, height)
    }
}

Setelah konteks dibuat, pengembang perlu mengonfigurasi buffer: vertex buffer (VBO) berisi koordinat vertex, normal, dan UV; index buffer (EBO) menentukan urutan traversal vertex untuk membentuk segitiga. VAO (Vertex Array Object) menggabungkan konfigurasi semua atribut dalam satu objek, mengurangi jumlah panggilan API saat mengganti mesh.

Konfigurasi konteks EGL

EGL (Native Platform Graphics Interface) — lapisan perantara antara OpenGL ES dan sistem jendela. Di Android, EGL mengelola pembuatan permukaan gambar, pemilihan konfigurasi framebuffer (kedalaman warna, stencil, MSAA), dan sinkronisasi dengan vsync. Konfigurasi tipikal meminta RGBA8888 dengan buffer depth 24-bit dan buffer stencil 8-bit. Di iOS, peran EGL dilakukan oleh EAGL dalam kombinasi dengan CAEAGLLayer.

Optimalisasi kinerja OpenGL ES pada perangkat mobile mencakup beberapa praktik kunci. Gunakan instancing (glDrawArraysInstanced) untuk rendering banyak objek identik — ini mengurangi jumlah panggilan draw. Terapkan kumpulan tekstur dan hindari pergantian tekstur antar panggilan draw. Urutkan objek berdasarkan shader, lalu tekstur, lalu mesh — urutan ini meminimalkan pergantian status konteks.

OpenGL ES vs Metal vs Vulkan

Metal — API grafis tingkat rendah dari Apple, tersedia di iOS dan macOS mulai dari chip A7. Metal menyediakan akses langsung ke GPU dengan overhead driver minimal, tetapi hanya berfungsi di perangkat Apple. Menurut data WWDC 2024, Metal memberikan kinerja hingga 40% lebih tinggi dibandingkan OpenGL ES pada perangkat keras yang sama dengan mengurangi jumlah pemeriksaan status saat runtime.

Vulkan — penerus lintas platform OpenGL ES, dikembangkan oleh Khronos Group. Vulkan menggunakan manajemen sumber daya eksplisit: pengembang sendiri mengalokasikan kumpulan memori, membuat buffer perintah, dan menyinkronkan akses ke GPU. Ini memberikan kontrol maksimal atas kinerja, tetapi kode inisialisasi Vulkan 3–4 kali lebih besar dari OpenGL ES. Vulkan direkomendasikan untuk game AAA dan aplikasi dengan grafis berat di Android 7+.

Pilihan antara OpenGL ES, Metal, dan Vulkan tergantung pada platform target dan persyaratan kinerja. OpenGL ES tetap menjadi pilihan terbaik untuk proyek lintas platform di mana kecepatan pengembangan penting. Metal lebih disukai untuk ekosistem iOS/macOS dengan kinerja maksimal. Vulkan — pilihan untuk proyek di mana setiap milidetik frame sangat penting, dan anggaran pengembangan memungkinkan investasi dalam optimasi tingkat rendah.