Crea un ambiente OpenGL ES

Per disegnare elementi grafici con OpenGL ES nella tua applicazione Android, devi creare un contenitore visualizzazione per tali elementi. Uno dei modi più semplici per raggiungere questo obiettivo è implementare sia un GLSurfaceView sia un GLSurfaceView.Renderer. GLSurfaceView è un contenitore di visualizzazioni per le immagini disegnate con OpenGL, mentre GLSurfaceView.Renderer controlla cosa viene disegnato all'interno di quella visualizzazione. Per ulteriori informazioni su queste classi, consulta la guida per gli sviluppatori di OpenGL ES.

GLSurfaceView è solo uno dei modi per incorporare la grafica OpenGL ES nella tua applicazione. Per una visualizzazione grafica a schermo intero o quasi a schermo intero, è una scelta ragionevole. Gli sviluppatori che vogliono incorporare elementi grafici OpenGL ES in una piccola parte dei propri layout dovrebbero dare un'occhiata a TextureView. Per gli sviluppatori fai da te, è anche possibile creare una visualizzazione OpenGL ES utilizzando SurfaceView, ma questo richiede la scrittura di un bel po' di codice aggiuntivo.

Questa lezione spiega come completare un'implementazione minima di GLSurfaceView e GLSurfaceView.Renderer in una semplice attività dell'applicazione.

Dichiara l'utilizzo di OpenGL ES nel file manifest

Affinché l'applicazione utilizzi l'API OpenGL ES 2.0, devi aggiungere la seguente dichiarazione al file manifest:

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

Se la tua applicazione utilizza la compressione delle texture, devi dichiarare anche i formati di compressione supportati dall'app, in modo che l'applicazione sia installata solo su dispositivi compatibili.

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

Per ulteriori informazioni sui formati di compressione delle texture, consulta la guida per gli sviluppatori OpenGL.

Crea un'attività per la grafica OpenGL ES

Le applicazioni Android che utilizzano OpenGL ES hanno attività come qualsiasi altra applicazione che dispone di un'interfaccia utente. La differenza principale rispetto alle altre applicazioni è lo spazio che inserisci nel layout della tua attività. Anche se in molte applicazioni potresti usare TextView, Button e ListView, in un'app che utilizza OpenGL ES puoi anche aggiungere GLSurfaceView.

Il seguente esempio di codice mostra un'implementazione minima di un'attività che utilizza GLSurfaceView come vista principale:

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

Nota: OpenGL ES 2.0 richiede Android 2.2 (livello API 8) o versioni successive, quindi assicurati che il tuo progetto Android abbia come target quell'API o una versione superiore.

Creazione di un oggetto GLSurfaceView

GLSurfaceView è una visualizzazione specializzata in cui puoi tracciare grafica OpenGL ES. Non fa molto da solo. Il disegno effettivo degli oggetti viene controllato nella sezione GLSurfaceView.Renderer che imposti in questa vista. In effetti, il codice di questo oggetto è così sottile che potresti essere tentato di saltare l'estensione e creare semplicemente un'istanza GLSurfaceView non modificata, ma non farlo. Devi estendere questa lezione per acquisire eventi touch, come illustrato nella lezione Rispondere agli eventi touch.

Il codice essenziale per un GLSurfaceView è minimo, quindi per un'implementazione rapida, è comune creare solo una classe interna nell'attività che la utilizza:

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

Un'altra aggiunta facoltativa all'implementazione di GLSurfaceView consiste nell'impostare la modalità di rendering in modo che veda la vista solo quando si verifica una modifica ai dati del disegno utilizzando l'impostazione 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);

Questa impostazione impedisce che il frame GLSurfaceView venga ridisegnato fino a quando non richiami requestRender(), il che è più efficiente per questa app di esempio.

Crea una classe del renderer

L'implementazione della classe GLSurfaceView.Renderer, o renderer, in un'applicazione che utilizza OpenGL ES è il punto in cui le cose iniziano a diventare interessanti. Questa classe controlla ciò che viene disegnato nell'oggetto GLSurfaceView a cui è associata. Esistono tre metodi in un renderer che vengono chiamati dal sistema Android per capire cosa e come disegnare su un GLSurfaceView:

• onSurfaceCreated() - Chiamata una volta per configurare l'ambiente OpenGL ES della visualizzazione.
• onDrawFrame() - Richiamato a ogni nuovo disegno della vista.
• onSurfaceChanged() - Richiamato se la geometria della vista cambia, ad esempio quando cambia l'orientamento dello schermo del dispositivo.

Di seguito è riportata un'implementazione molto basilare di un renderer OpenGL ES, che non fa altro che disegnare uno sfondo nero nel 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);
    }
}

Questo è tutto. Gli esempi di codice riportati sopra creano una semplice applicazione Android che mostra una schermata nera con OpenGL. Anche se questo codice non è molto interessante, con la creazione di queste classi hai gettato le basi per iniziare a disegnare elementi grafici con OpenID.

Nota:potresti chiederti perché questi metodi hanno un parametro GL10 quando utilizzi le API OpengGL ES 2.0. Queste firme dei metodi vengono semplicemente riutilizzate per le API 2.0 al fine di mantenere il codice del framework Android più semplice.

Se conosci le API OpenGL ES, ora dovresti essere in grado di configurare un ambiente OpenGL ES nella tua app e iniziare a disegnare grafica. Se, però, hai bisogno di un po' più di aiuto per iniziare a usare OpenGL, passa alle lezioni successive per altri suggerimenti.