Sviluppare un gioco per Android – Lezione 11: da Canvas a OpenGL ES

Sviluppare un gioco per Android – Lezione 11: da Canvas a OpenGL ES
Android Blog Italia.

La prima parte della guida è conclusa, ed è giunta l’ora di approfondire le capacità grafiche della piattaforma Android. Il sistema operativo in questione supporta, come molti di voi sapranno, le API OpenGL ES. Vi siete mai chiesti per quale motivo molti sviluppatori utilizzino queste ultime piuttosto che quelle standard Android? Il motivo è semplice: scaricare la gestione della grafica alla GPU. Con quello che abbiamo fatto fino ad ora, abbiamo addossato il carico di lavoro solo alla CPU e, considerando che gli smartphone Android hanno una GPU dedicata, perché non sfruttarla? Vediamo, dunque, come fare.

Se avete seguito tutte le lezioni, avete appreso l’utilizzo di SurfaceView e dell’oggetto Canvas, la tela dentro la quale disegniamo. Utilizzando OpenGL ES il procedimento non è poi così diverso. Per effettuare il rendering di oggetti OpenGL, infatti, utilizziamo un’implementazione apposita di SurfaceView e un renderer OpenGL. Se siete pronti, possiamo iniziare.

Creazione del renderer OpenGL

Il primo passo consiste nell’implementare la classe GlRenderer, che potete vedere qui di seguito.

package com.example.lezioneopengl_androidblog;

import javax.microedition.khronos.egl.EGLConfig;
import javax.microedition.khronos.opengles.GL10;

import android.opengl.GLSurfaceView.Renderer;

public class GlRenderer implements Renderer {

	@Override
	public void onDrawFrame(GL10 gl) {
		// TODO Auto-generated method stub

	}

	@Override
	public void onSurfaceChanged(GL10 gl, int width, int height) {
		// TODO Auto-generated method stub

	}

	@Override
	public void onSurfaceCreated(GL10 gl, EGLConfig config) {
		// TODO Auto-generated method stub

	}

}

Al momento, trattandosi di una lezione introduttiva su OpenGL ES, lasceremo i tre metodi vuoti, quindi non faranno nulla e nella prossima lezione vedremo come utilizzarne qualcuno, l’importante è capire, per il momento, a cosa servono. Inoltre, come potete vedere, abbiamo implementato l’interfaccia android.opengl.GLSurfaceView.Renderer.

I metodi e l’attività principale

Diamo un’occhiata ai tre metodi del nostro renderer OpenGL:

• onSurfaceCreated(GL10 gl, EGLConfig config): è molto importante poiché ogni volta che il nostro dispositivo va in stato di sleep, è questo il metodo che viene utilizzato per ricreare la superficie (non solo per crearla quindi!). Questo, infatti, è il posto dove verranno caricate le nostre risorse (immagini, etc.) poiché dovete ricordare che, in stato di sleep, queste ultime vengono distrutte assieme al contesto di gioco;
• onSurfaceChanged(GL10 gl, int width, int height) : viene chiamato ogni volta che cambiano le dimensioni della nostra superficie; Principalmente, esso apporta modifiche alla nostra viewport, una regione rettangolare attraverso la quale vediamo il nostro gioco;
• onDrawFrame(GL10 gl): viene chiamato dal thread di rendering (creato di default da Android) per disegnare ogni singola immagine. Tutte le attività dedicate al disegno avvengono qui.

Vediamo, a questo punto, la nostra classe MainActivity.java:

public class MainActivity extends Activity {

	/** La view OpenGL */
	private GLSurfaceView glSurfaceView;

    /** Called when the activity is first created. */
    @Override
    public void onCreate(Bundle savedInstanceState) {
        super.onCreate(savedInstanceState);

        requestWindowFeature(Window.FEATURE_NO_TITLE);
		getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,
				WindowManager.LayoutParams.FLAG_FULLSCREEN);

        // inizializza la view OpenGL e
        // crea un'istanza con questa Activity
        glSurfaceView = new GLSurfaceView(this);

        // setta il nostro renderer principale
        glSurfaceView.setRenderer(new GlRenderer());
        setContentView(glSurfaceView);
    }

	@Override
	protected void onResume() {
		super.onResume();
		glSurfaceView.onResume();
	}

	@Override
	protected void onPause() {
		super.onPause();
		glSurfaceView.onPause();
	}

}

Al rigo 4 abbiamo dichiarato la nostra view OpenGL fornita da Android: GLSurfaceView. Al rigo 17 l’abbiamo istanziata mentre al rigo 20 abbiamo passato il renderer alla view. Infine, al rigo 21, abbiamo informato la nostra attività di utilizzare la view OpenGL. I metodi onResume() e onPause() vengono sovrascritti e attivano i rispettivi metodi nella nostra view. Se provate ad avviare l’applicazione ora, avrete di fronte una schermata vuota.

Questo è tutto, siamo passati finalmente ad una configurazione OpenGL ES. Nella prossima lezione approfondiremo il discorso iniziando a parlare di come vengono visualizzati gli elementi, di quali sono quelli primitivi e, naturalmente, faremo qualche accenno ai concetti base di programmazione 3D. Per qualunque dubbio o chiarimento, come di consueto, non esitate a commentare l’articolo.

Sviluppare un gioco per Android – Lezione 11: da Canvas a OpenGL ES
Android Blog Italia.