Membuat lingkungan OpenGL ES

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:

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)
    }
}

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:

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)
    }
}

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:

// Render the view only when there is a change in the drawing data
renderMode = GLSurfaceView.RENDERMODE_WHEN_DIRTY

// 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:

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)
    }
}

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.