Untuk menggambar grafis dengan OpenGL ES di aplikasi Android, Anda harus membuat
container tampilan untuk grafis tersebut. Salah satu cara yang lebih mudah untuk melakukannya adalah dengan mengimplementasikan
GLSurfaceView
dan GLSurfaceView.Renderer
. GLSurfaceView
adalah penampung tampilan untuk grafis yang digambar dengan OpenGL dan
GLSurfaceView.Renderer
mengontrol apa yang digambar dalam tampilan tersebut. Untuk informasi selengkapnya
tentang class ini, lihat panduan developer
OpenGL ES.
GLSurfaceView
hanyalah salah satu cara untuk menggabungkan grafis OpenGL ES ke dalam aplikasi
Anda. Untuk tampilan grafis layar penuh atau mendekati penuh, cara ini merupakan pilihan tepat.
Developer yang ingin menggabungkan grafis OpenGL ES di sebagian kecil tata letak dapat
melihat TextureView
. Developer mandiri juga dapat
mem-build tampilan OpenGL ES menggunakan SurfaceView
, tetapi hal ini memerlukan
penulisan kode tambahan yang cukup banyak.
Tutorial ini menjelaskan cara menyelesaikan implementasi minimal GLSurfaceView
dan GLSurfaceView.Renderer
dalam aktivitas
aplikasi sederhana.
Mendeklarasikan penggunaan OpenGL ES dalam manifes
Agar aplikasi dapat menggunakan OpenGL ES 2.0 API, Anda harus menambahkan deklarasi berikut ke manifes:
<uses-feature android:glEsVersion="0x00020000" android:required="true" />
Jika aplikasi menggunakan kompresi tekstur, Anda juga harus mendeklarasikan format kompresi yang didukung aplikasi sehingga hanya diinstal di perangkat yang kompatibel.
<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" /> <supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />
Untuk informasi selengkapnya tentang format kompresi tekstur, lihat panduan developer OpenGL.
Membuat aktivitas untuk grafis OpenGL ES
Aplikasi Android yang menggunakan OpenGL ES memiliki aktivitas seperti aplikasi lain yang memiliki
antarmuka pengguna. Perbedaan utama dari aplikasi lain adalah apa yang Anda masukkan ke dalam tata letak untuk
aktivitas Anda. Meskipun di banyak aplikasi, Anda mungkin menggunakan TextView
, Button
, dan ListView
, di aplikasi yang menggunakan OpenGL ES, Anda juga dapat
menambahkan GLSurfaceView
.
Contoh kode berikut menunjukkan implementasi minimal dari aktivitas yang menggunakan
GLSurfaceView
sebagai tampilan utamanya:
Kotlin
class OpenGLES20Activity : Activity() { private lateinit var gLView: GLSurfaceView public override fun onCreate(savedInstanceState: Bundle?) { super.onCreate(savedInstanceState) // Create a GLSurfaceView instance and set it // as the ContentView for this Activity. gLView = MyGLSurfaceView(this) setContentView(gLView) } }
Java
public class OpenGLES20Activity extends Activity { private GLSurfaceView gLView; @Override public void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); // Create a GLSurfaceView instance and set it // as the ContentView for this Activity. gLView = new MyGLSurfaceView(this); setContentView(gLView); } }
Catatan: OpenGL ES 2.0 memerlukan Android 2.2 (API Level 8) atau yang lebih tinggi, jadi pastikan project Android Anda menargetkan API tersebut atau yang lebih tinggi.
Membuat objek GLSurfaceView
GLSurfaceView
adalah tampilan khusus tempat Anda dapat menggambar grafis
OpenGL ES.
Objek ini tidak melakukan banyak hal sendirian. Penggambaran objek yang sebenarnya dikontrol dalam
GLSurfaceView.Renderer
yang Anda tetapkan pada tampilan ini. Bahkan, kode untuk objek ini
sangat singkat sehingga Anda mungkin tergoda untuk tidak memperluasnya dan hanya membuat instance
GLSurfaceView
tanpa modifikasi. Namun, jangan lakukan itu. Anda harus memperluas class ini agar
dapat menangkap peristiwa sentuh, yang akan dibahas dalam tutorial Merespons peristiwa
sentuh.
Kode penting untuk GLSurfaceView
bersifat minimal, jadi untuk implementasi
cepat, biasanya Anda hanya
membuat class dalam di aktivitas yang menggunakannya:
Kotlin
import android.content.Context import android.opengl.GLSurfaceView class MyGLSurfaceView(context: Context) : GLSurfaceView(context) { private val renderer: MyGLRenderer init { // Create an OpenGL ES 2.0 context setEGLContextClientVersion(2) renderer = MyGLRenderer() // Set the Renderer for drawing on the GLSurfaceView setRenderer(renderer) } }
Java
import android.content.Context; import android.opengl.GLSurfaceView; class MyGLSurfaceView extends GLSurfaceView { private final MyGLRenderer renderer; public MyGLSurfaceView(Context context){ super(context); // Create an OpenGL ES 2.0 context setEGLContextClientVersion(2); renderer = new MyGLRenderer(); // Set the Renderer for drawing on the GLSurfaceView setRenderer(renderer); } }
Satu tambahan opsional lainnya untuk implementasi GLSurfaceView
adalah menyetel
mode render agar hanya menggambar tampilan ketika ada perubahan pada data gambar menggunakan
setelan
GLSurfaceView.RENDERMODE_WHEN_DIRTY
:
Kotlin
// Render the view only when there is a change in the drawing data renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY
Java
// Render the view only when there is a change in the drawing data setRenderMode(GLSurfaceView.RENDERMODE_WHEN_DIRTY);
Setelan ini mencegah frame GLSurfaceView
digambar ulang sampai Anda
memanggil requestRender()
, yang lebih
efisien untuk aplikasi contoh ini.
Membuat class perender
Implementasi class GLSurfaceView.Renderer
, atau perender,
dalam aplikasi yang menggunakan OpenGL ES adalah bagian paling menarik. Class ini mengontrol apa yang digambar di GLSurfaceView
yang terkait. Ada
tiga metode dalam perender yang dipanggil oleh sistem Android untuk mencari tahu apa dan
cara menggambar di GLSurfaceView
:
onSurfaceCreated()
- Dipanggil sekali untuk menyiapkan lingkungan OpenGL ES tampilan.onDrawFrame()
- Dipanggil untuk setiap penggambaran ulang tampilan.onSurfaceChanged()
- Dipanggil jika geometri tampilan berubah, misalnya saat orientasi layar perangkat berubah.
Berikut adalah implementasi yang sangat dasar dari perender OpenGL ES, yang tidak berfungsi apa pun selain menggambar
latar belakang hitam di GLSurfaceView
:
Kotlin
import javax.microedition.khronos.egl.EGLConfig import javax.microedition.khronos.opengles.GL10 import android.opengl.GLES20 import android.opengl.GLSurfaceView class MyGLRenderer : GLSurfaceView.Renderer { override fun onSurfaceCreated(unused: GL10, config: EGLConfig) { // Set the background frame color GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f) } override fun onDrawFrame(unused: GL10) { // Redraw background color GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT) } override fun onSurfaceChanged(unused: GL10, width: Int, height: Int) { GLES20.glViewport(0, 0, width, height) } }
Java
import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.opengl.GLES20; import android.opengl.GLSurfaceView; public class MyGLRenderer implements GLSurfaceView.Renderer { public void onSurfaceCreated(GL10 unused, EGLConfig config) { // Set the background frame color GLES20.glClearColor(0.0f, 0.0f, 0.0f, 1.0f); } public void onDrawFrame(GL10 unused) { // Redraw background color GLES20.glClear(GLES20.GL_COLOR_BUFFER_BIT); } public void onSurfaceChanged(GL10 unused, int width, int height) { GLES20.glViewport(0, 0, width, height); } }
Selesai! Contoh kode di atas membuat aplikasi Android sederhana yang menampilkan layar hitam menggunakan OpenGL. Meskipun kode ini tidak melakukan sesuatu yang menarik, dengan membuat class ini, Anda telah meletakkan fondasi yang diperlukan untuk mulai menggambar elemen grafis dengan OpenGL.
Catatan: Anda mungkin bertanya-tanya mengapa metode ini memiliki parameter GL10
, saat Anda menggunakan OpengGL ES 2.0 API.
Tanda tangan metode ini hanya digunakan kembali untuk API 2.0 agar kode framework Android
lebih sederhana.
Jika sudah terbiasa dengan OpenGL ES API, kini Anda seharusnya dapat menyiapkan lingkungan OpenGL ES di aplikasi dan mulai menggambar grafis. Namun, jika Anda memerlukan bantuan lebih lanjut untuk memulai OpenGL, lanjutkan ke tutorial berikutnya untuk mendapatkan beberapa petunjuk lainnya.