Crea un ambiente OpenGL ES

Per disegnare grafica con OpenGL ES nell'applicazione Android, devi creare un'immagine visualizzare il container corrispondente. Uno dei modi più semplici per farlo è implementare sia un GLSurfaceView e GLSurfaceView.Renderer. R GLSurfaceView è un container di visualizzazione per le grafiche disegnate con OpenGL e GLSurfaceView.Renderer controlla gli elementi disegnati all'interno della visualizzazione selezionata. Per ulteriori informazioni su questi corsi, consulta il documento OpenGL ES guida per gli sviluppatori.

GLSurfaceView è solo un modo per incorporare la grafica OpenGL ES nel tuo un'applicazione. Per una visualizzazione grafica a schermo intero o quasi a schermo intero, è una scelta ragionevole. Gli sviluppatori che desiderano incorporare la grafica OpenGL ES in una piccola parte dei propri layout devono dai un'occhiata a TextureView. Per i veri sviluppatori fai da te, è anche è possibile creare una vista OpenGL ES utilizzando SurfaceView, ma questa operazione richiede un bel po' di codice aggiuntivo.

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

Dichiara l'utilizzo di OpenGL ES nel file manifest

Per consentire alla tua applicazione di utilizzare l'API OpenGL ES 2.0, devi aggiungere quanto segue dichiarazione al file manifest:

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

Se l'applicazione utilizza la compressione delle texture, devi anche dichiarare i formati di compressione. supportata dalla tua app, affinché venga installata soltanto 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 Guida per gli sviluppatori OpenGL.

Creare un'attività per la grafica OpenGL ES

Le applicazioni Android che utilizzano OpenGL ES hanno attività proprio come qualsiasi altra applicazione che abbia un'interfaccia utente. La differenza principale rispetto ad altre applicazioni è ciò che inserisci nel layout per il tuo attività. In molte applicazioni potresti usare TextView, Button e ListView, mentre in un'app che usa OpenGL ES, puoi aggiungi anche GLSurfaceView.

L'esempio di codice riportato di seguito mostra un'implementazione minima di un'attività che utilizza un 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 successiva.

Crea un oggetto GLSurfaceView

Un GLSurfaceView è una vista specializzata in cui puoi disegnare OpenGL ES le immagini. Non produce molto da solo. Il disegno effettivo degli oggetti è controllato GLSurfaceView.Renderer impostata in questa vista. Infatti, il codice è così sottile che si tende a ignorare l'estensione e si crea GLSurfaceView, ma non farlo. Devi ampliare questo corso per acquisire gli eventi di tocco, come descritto nella sezione Risposta al tocco eventi.

Il codice essenziale per un GLSurfaceView è minimo, quindi per una breve implementazione, è pratica comune crea 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 è l'impostazione la modalità di rendering per disegnare la vista solo quando viene apportata una modifica ai dati del disegno utilizzando il GLSurfaceView.RENDERMODE_WHEN_DIRTY dell'impostazione:

// 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 chiama requestRender(), che è efficiente per questa app di esempio.

Creazione di una classe di renderer

L'implementazione della classe o renderer GLSurfaceView.Renderer all'interno di un'applicazione che usa OpenGL ES è dove le cose iniziano a diventare interessanti. Questo corso controlli ciò che viene disegnato in GLSurfaceView a cui è associato. Esistono tre metodi in un renderer chiamati dal sistema Android per capire cosa e come disegnare su un GLSurfaceView:

• onSurfaceCreated() - Chiamata una volta per impostare l'ambiente OpenGL ES della visualizzazione.
• onDrawFrame() - Richiamato per ciascuno ridisegno della vista.
• onSurfaceChanged() - Chiamato se la geometria della visualizzazione 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 un sfondo nero in 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 precedenti creano una semplice applicazione per Android che mostra una schermata nera in OpenGL. Anche se questo codice non fa nulla di molto interessante, creando questi corsi, hai gettato le basi per iniziare a disegnare elementi grafici con OpenGL.

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

Se hai familiarità con le API OpenGL ES, ora dovresti essere in grado di configurare un protocollo OpenGL ES nell'app e iniziare a tracciare le grafiche. Tuttavia, se hai bisogno di ulteriore assistenza per inizia con OpenGL, passa alle lezioni successive per altri suggerimenti.