Halaman ini diterjemahkan oleh Cloud Translation API.

Membuat lingkungan OpenGL ES

Untuk menggambar grafik dengan OpenGL ES di aplikasi Android, Anda harus membuat container-nya. Salah satu cara yang lebih sederhana untuk melakukannya adalah dengan menerapkan GLSurfaceView dan GLSurfaceView.Renderer. J GLSurfaceView adalah container tampilan untuk grafis yang digambar dengan OpenGL dan GLSurfaceView.Renderer mengontrol apa yang digambar dalam tampilan tersebut. Untuk informasi lebih lanjut tentang class ini, lihat panduan OpenGL ES panduan developer.

GLSurfaceView hanyalah salah satu cara untuk menggabungkan grafis OpenGL ES ke dalam aplikasi. 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 harus lihat TextureView. Untuk pengembang {i>DIY<i} sendiri, itu juga merupakan tampilan OpenGL ES dapat dibuat menggunakan SurfaceView, tetapi hal ini memerlukan menulis cukup banyak kode tambahan.

Tutorial ini menjelaskan cara menyelesaikan implementasi minimal dari GLSurfaceView dan GLSurfaceView.Renderer secara sederhana aktivitas aplikasi Anda.

Mendeklarasikan penggunaan OpenGL ES dalam manifes

Agar aplikasi Anda dapat menggunakan OpenGL ES 2.0 API, Anda harus menambahkan hal berikut ke manifes:

<uses-feature android:glEsVersion="0x00020000" android:required="true" />

Jika aplikasi Anda menggunakan kompresi tekstur, Anda juga harus mendeklarasikan format kompresi mana yang didukung aplikasi Anda, 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 seperti aplikasi lainnya yang memiliki antarmuka pengguna. Perbedaan utama dari aplikasi lain adalah apa yang Anda letakkan ke dalam tata letak untuk aktivitas Anda. Meskipun di banyak aplikasi, Anda mungkin menggunakan TextView, Button, dan ListView, pada aplikasi yang menggunakan OpenGL ES, Anda dapat juga 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 proyek Android Anda menargetkan API tersebut atau yang lebih tinggi.

Membuat objek GLSurfaceView

GLSurfaceView adalah tampilan khusus tempat Anda dapat menggambar OpenGL ES grafis. Objek ini tidak melakukan banyak hal sendirian. Penggambaran objek sebenarnya dikontrol di GLSurfaceView.Renderer yang Anda tetapkan pada tampilan ini. Bahkan, kode untuk ini sangat tipis, Anda mungkin tergoda untuk melewatkannya dan hanya membuat objek GLSurfaceView, tetapi jangan lakukan itu. Anda perlu memperluas class ini di untuk menangkap peristiwa sentuh, yang tercakup dalam fitur Merespons sentuhan peristiwa.

Kode penting untuk GLSurfaceView tidak terlalu besar, jadi untuk adalah hal yang umum untuk cukup buat inner class 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 penerapan GLSurfaceView adalah menetapkan mode render untuk hanya menggambar tampilan bila ada perubahan pada data gambar dengan menggunakan GLSurfaceView.RENDERMODE_WHEN_DIRTY setelan:

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 titik di mana semuanya mulai menjadi menarik. Kelas ini kontrol 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 menggambar 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 melakukan 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 kelas-kelas 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 guna menjaga kode framework Android lebih mudah.

Jika sudah terbiasa dengan OpenGL ES API, kini Anda seharusnya dapat menyiapkan OpenGL ES di aplikasi Anda dan mulailah menggambar. Namun, jika Anda memerlukan lebih banyak bantuan untuk dimulai dengan OpenGL, lanjutkan ke pelajaran berikutnya untuk mendapatkan lebih banyak petunjuk.