Créer un environnement OpenGL ES

Pour dessiner des graphiques avec OpenGL ES dans votre application Android, vous devez créer un conteneur de vue. Pour ce faire, l'une des méthodes les plus simples consiste à implémenter à la fois un GLSurfaceView et un GLSurfaceView.Renderer. Un GLSurfaceView est un conteneur de vue pour les graphiques dessinés avec OpenGL, et GLSurfaceView.Renderer contrôle ce qui est dessiné dans cette vue. Pour en savoir plus sur ces classes, consultez le guide du développeur OpenGL ES.

GLSurfaceView n'est qu'une méthode parmi d'autres pour intégrer des éléments graphiques OpenGL ES à votre application. Pour obtenir une vue graphique plein écran ou presque, il s'agit d'un choix judicieux. Les développeurs qui souhaitent intégrer des graphiques OpenGL ES dans une petite partie de leurs mises en page doivent consulter TextureView. Pour les développeurs authentiques, il est également possible de créer une vue OpenGL ES à l'aide de SurfaceView, mais cela nécessite d'écrire un peu de code supplémentaire.

Cette leçon explique comment effectuer une implémentation minimale de GLSurfaceView et GLSurfaceView.Renderer dans une activité d'application simple.

Déclarer l'utilisation d'OpenGL ES dans le fichier manifeste

Pour que votre application utilise l'API OpenGL ES 2.0, vous devez ajouter la déclaration suivante à votre fichier manifeste:

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

Si votre application utilise la compression de texture, vous devez également déclarer les formats de compression compatibles avec votre application afin qu'elle ne soit installée que sur les appareils compatibles.

<supports-gl-texture android:name="GL_OES_compressed_ETC1_RGB8_texture" />
<supports-gl-texture android:name="GL_OES_compressed_paletted_texture" />

Pour en savoir plus sur les formats de compression de texture, consultez le guide du développeur OpenGL.

Créer une activité pour les éléments graphiques OpenGL ES

Les applications Android qui utilisent OpenGL ES ont des activités comme n'importe quelle autre application disposant d'une interface utilisateur. La principale différence par rapport aux autres applications est ce que vous mettez dans la mise en page de votre activité. Bien que de nombreuses applications puissent utiliser TextView, Button et ListView, vous pouvez également ajouter un GLSurfaceView dans une application utilisant OpenGL ES.

L'exemple de code suivant présente une implémentation minimale d'une activité qui utilise un GLSurfaceView comme vue principale:

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

Remarque:OpenGL ES 2.0 nécessite Android 2.2 (niveau d'API 8) ou version ultérieure. Assurez-vous donc que votre projet Android cible cette API ou une version ultérieure.

Créer un objet GLSurfaceView

Un GLSurfaceView est une vue spécialisée dans laquelle vous pouvez dessiner des graphiques OpenGL ES. Il ne fait pas grand-chose en soi. Le dessin réel des objets est contrôlé dans le GLSurfaceView.Renderer que vous définissez pour cette vue. En fait, le code de cet objet est si léger que vous pourriez être tenté de ne pas l'étendre et de simplement créer une instance GLSurfaceView non modifiée, mais ne le faites pas. Vous devez étendre cette classe pour capturer des événements tactiles, comme expliqué dans la leçon Répondre aux événements tactiles.

Le code essentiel d'un GLSurfaceView est minimal. Pour une implémentation rapide, il est donc courant de simplement créer une classe interne dans l'activité qui l'utilise:

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

Un autre ajout facultatif à votre implémentation de GLSurfaceView consiste à définir le mode de rendu pour ne dessiner la vue qu'en cas de modification de vos données de dessin à l'aide du paramètre 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);

Ce paramètre empêche le redessin du frame GLSurfaceView tant que vous n'appelez pas requestRender(), ce qui est plus efficace pour cette application exemple.

Créer une classe de moteur de rendu

L'implémentation de la classe (ou moteur de rendu) GLSurfaceView.Renderer dans une application qui utilise OpenGL ES est l'étape à laquelle les choses commencent à devenir intéressantes. Cette classe contrôle ce qui est affiché sur l'élément GLSurfaceView auquel elle est associée. Dans un moteur de rendu, trois méthodes sont appelées par le système Android afin de déterminer quoi dessiner sur un GLSurfaceView et comment:

  • onSurfaceCreated() : appelé une fois pour configurer l'environnement OpenGL ES de la vue.
  • onDrawFrame() : appelé pour chaque redessin de la vue.
  • onSurfaceChanged() : appelé si la géométrie de la vue change, par exemple lorsque l'orientation de l'écran de l'appareil change.

Voici une implémentation très basique d'un moteur de rendu OpenGL ES, qui ne fait rien de plus que dessiner un arrière-plan noir dans 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);
    }
}

C'est aussi simple que cela ! Les exemples de code ci-dessus créent une application Android simple qui affiche un écran noir à l'aide d'OpenGL. Bien que ce code ne fasse rien de très intéressant, en créant ces classes, vous avez établi les bases nécessaires pour commencer à dessiner des éléments graphiques avec OpenGL.

Remarque:Vous vous demandez peut-être pourquoi ces méthodes comportent un paramètre GL10 lorsque vous utilisez les API OpengGL ES 2.0. Ces signatures de méthode sont simplement réutilisées pour les API 2.0 afin de simplifier le code du framework Android.

Si vous connaissez les API OpenGL ES, vous devriez maintenant pouvoir configurer un environnement OpenGL ES dans votre application et commencer à dessiner des éléments graphiques. Toutefois, si vous avez besoin d'un peu plus d'aide pour vous familiariser avec OpenGL, passez aux leçons suivantes pour quelques conseils supplémentaires.