Agar dapat menggambar grafis dengan OpenGL ES di aplikasi Android, Anda harus membuat container tampilan untuk grafis tersebut. Salah satu cara yang mudah untuk membuat container tampilan adalah dengan mengimplementasikan GLSurfaceView dan GLSurfaceView.Renderer. GLSurfaceView adalah container 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 membuat tampilan OpenGL ES menggunakan SurfaceView, tetapi hal ini memerlukan penulisan kode tambahan yang cukup panjang.
Tutorial ini menjelaskan cara menyelesaikan implementasi minimal GLSurfaceView dan GLSurfaceView.Renderer dalam aktivitas aplikasi sederhana.
Mendeklarasikan penggunaan OpenGL ES dalam manifes
Agar aplikasi menggunakan OpenGL ES 2.0 API, Anda harus menambahkan deklarasi berikut ke manifes:
<uses-feature android:glEsVersion="0x00020000" android:required="true" />
Jika aplikasi Anda menggunakan kompresi tekstur, deklarasikan juga format kompresi yang didukung aplikasi tersebut sehingga hanya diinstal pada 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 yang sama seperti aplikasi lain yang menggunakan antarmuka pengguna. Perbedaan utamanya terletak pada informasi yang Anda masukkan ke dalam tata letak untuk aktivitas Anda. Sementara 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 sebenarnya dikontrol dalam GLSurfaceView.Renderer yang Anda tetapkan pada tampilan ini. Bahkan, kode untuk objek ini sedemikian singkatnya sehingga Anda mungkin tergoda untuk tidak memperluas kode ini dan langsung membuat instance GLSurfaceView tanpa modifikasi. Namun, jangan lakukan hal itu. Anda harus memperluas class ini agar dapat menangkap peristiwa sentuh, yang akan dibahas dalam tutorial Merespons peristiwa sentuh.
Kode pokok untuk GLSurfaceView tidak seberapa panjang, jadi untuk implementasi cepat, biasanya Anda hanya perlu membuat inner class dalam 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 jika ada perubahan pada data gambar Anda 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 pada GLSurfaceView yang terkait. Ada tiga metode dalam perender yang dipanggil oleh sistem Android untuk mencari tahu apa dan bagaimana 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 menghasilkan aplikasi Android sederhana yang menampilkan layar hitam menggunakan OpenGL. Meskipun kode ini tidak memiliki kegunaan yang menarik, dengan membuat class ini, Anda telah menetapkan fondasi yang diperlukan untuk mulai menggambar elemen grafis dengan OpenGL.
Catatan: Anda mungkin heran mengapa metode ini memiliki parameter GL10, jika Anda menggunakan OpenGL ES 2.0 API. Tanda tangan metode ini hanya digunakan kembali untuk OpenGL ES 2.0 API agar kode framework Android lebih sederhana.
Jika sudah terbiasa dengan OpenGL ES API, sekarang Anda tentu sudah bisa menyiapkan lingkungan OpenGL ES di aplikasi Anda dan mulai menggambar grafis. Namun, jika Anda memerlukan bantuan lebih lanjut untuk memulai OpenGL, lanjutkan ke tutorial berikutnya untuk mendapatkan lebih banyak petunjuk.