Cette page a été traduite par l'API Cloud Translation.

Créer un environnement OpenGL ES

Pour dessiner des graphismes avec OpenGL ES dans votre application Android, vous devez créer un pour afficher le conteneur correspondant. L'une des méthodes les plus simples pour y parvenir est d'implémenter à la fois GLSurfaceView et GLSurfaceView.Renderer. A GLSurfaceView est un conteneur de vue pour les éléments 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 document OpenGL ES guide du développeur.

GLSurfaceView n'est qu'un moyen parmi d'autres d'intégrer des graphismes OpenGL ES à votre application. Pour un affichage graphique en plein écran ou presque en plein écran, il s'agit d'un choix raisonnable. Les développeurs qui souhaitent intégrer des graphismes OpenGL ES dans une petite partie de leurs mises en page doivent regardez TextureView. Pour les développeurs, c'est aussi possible de créer une vue OpenGL ES à l'aide de SurfaceView, mais cela nécessite vous devez écrire beaucoup de code supplémentaire.

Cette leçon explique comment effectuer une implémentation minimale de GLSurfaceView et GLSurfaceView.Renderer de manière simple l'activité dans les applications.

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 les éléments suivants : à 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 compatible avec votre application, de sorte qu'elle ne soit installée que sur des 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 la 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 qui a une interface utilisateur. La principale différence par rapport aux autres applications est la disposition de votre activité. Bien que vous puissiez utiliser TextView, Button et ListView dans de nombreuses applications, vous pouvez utiliser OpenGL ES dans une application qui utilise OpenGL ES. ajoutez également un GLSurfaceView.

L'exemple de code suivant montre 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 OpenGL ES graphiques. Elle ne fait pas grand-chose par elle-même. Le dessin des objets est contrôlé GLSurfaceView.Renderer que vous avez définie dans cette vue. En fait, le code est si fin que vous pouvez être tenté de ne pas l'étendre et de créer simplement GLSurfaceView, mais ne le faites pas. Vous devez prolonger ce cours dans pour capturer les événements tactiles, qui sont décrits dans la section événements.

Le code essentiel pour un GLSurfaceView est minimal. Pour effectuer rapidement mise en œuvre, il est courant créez simplement 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 que si vos données de dessin sont modifiées à l'aide de la méthode 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 frame GLSurfaceView d'être redessiné tant que vous n'avez pas appelez requestRender(), ce qui est plus efficace pour cette application exemple.

Créer une classe de moteur de rendu

L'implémentation de la classe GLSurfaceView.Renderer (ou moteur de rendu) dans une application qui utilise OpenGL ES, c'est là que les choses commencent à devenir intéressantes. Ce cours commandes ce qui est dessiné sur le GLSurfaceView auquel il est associé. Il y a trois méthodes d'un moteur de rendu appelées par le système Android afin de déterminer comment dessiner sur un GLSurfaceView:

onSurfaceCreated() – Appelé une fois pour configurer l'environnement OpenGL ES de la vue.
onDrawFrame() - Appelé pour chaque redessiner 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 permet uniquement de 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 tout ! Les exemples de code ci-dessus créent une application Android simple qui affiche un écran noir avec OpenGL. Bien que ce code ne fasse rien d'intéressant, en créant ces classes, vous avez jeté 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 conserver le code du framework Android. plus simple.

Si vous connaissez les API OpenGL ES, vous devriez maintenant être en mesure de configurer un dans votre application et commencez à dessiner des graphiques. Cependant, si vous avez besoin d’un peu plus d’aide pour que vous avez commencé avec OpenGL, consultez les leçons suivantes pour découvrir d'autres astuces.