Cómo construir un entorno de OpenGL ES

Organiza tus páginas con colecciones Guarda y categoriza el contenido según tus preferencias.

Para dibujar gráficos con OpenGL ES en tu aplicación para Android, debes crear una el contenedor de datos para ellos. Una de las formas más directas de hacerlo es implementar un GLSurfaceView y GLSurfaceView.Renderer. R GLSurfaceView es un contenedor de vistas para gráficos dibujados con OpenGL y GLSurfaceView.Renderer controla lo que se dibuja en esa vista. Más información acerca de estas clases, consulta OpenGL ES de la guía para desarrolladores.

GLSurfaceView es solo una forma de incorporar gráficos de OpenGL ES en tus y mantener la integridad de su aplicación. Para una vista de gráficos de pantalla completa o casi completa, es una opción razonable. Los desarrolladores que quieran incorporar gráficos de OpenGL ES en una pequeña parte de sus diseños deberían hacer lo siguiente: consulta TextureView. Para los desarrolladores que hacen lo propio, también es es posible crear una vista de OpenGL ES con SurfaceView, pero esto requiere escribir bastante código adicional.

En esta lección, se explica cómo completar una implementación mínima de GLSurfaceView y GLSurfaceView.Renderer de una manera sencilla la actividad de la aplicación.

Cómo declarar el uso de OpenGL ES en el manifiesto

Para que tu aplicación use la API de OpenGL ES 2.0, debes agregar lo siguiente a tu manifiesto:

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

Si tu aplicación usa compresión de texturas, también debes declarar qué formatos de compresión que tu app admite para que solo se instale en dispositivos compatibles.

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

Para obtener más información sobre los formatos de compresión de texturas, consulta la OpenGL para desarrolladores.

Crea una actividad para los gráficos de OpenGL ES

Las aplicaciones para Android que usan OpenGL ES tienen actividades como cualquier otra aplicación que tenga una interfaz de usuario. La principal diferencia con otras aplicaciones es lo que colocas en el diseño de tu actividad. Si bien en muchas aplicaciones puedes usar TextView, Button y ListView, en una app que usa OpenGL ES, puedes también agrega un GLSurfaceView.

El siguiente ejemplo de código muestra una implementación mínima de una actividad que usa un GLSurfaceView como su vista principal:

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 requiere Android 2.2 (nivel de API 8) o una versión posterior, Por lo tanto, asegúrate de que tu proyecto de Android se oriente a esa API o a versiones posteriores.

Cómo construir un objeto GLSurfaceView

Una GLSurfaceView es una vista especializada en la que puedes dibujar OpenGL ES gráficos. No hace mucho por sí sola. El dibujo real de los objetos se controla en el GLSurfaceView.Renderer que estableciste en esta vista. De hecho, el código para esta objeto es tan delgado que podrías sentirte tentado a no extenderlo y solo crear una GLSurfaceView, pero no hagas eso. Debes extender esta clase en para capturar eventos táctiles, lo cual se describe en la sección Responde a eventos táctiles eventos.

El código esencial de un GLSurfaceView es mínimo, así que, para de implementación, es común que simplemente crea una clase interna en la actividad que la usa:

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

Otra adición opcional a tu implementación de GLSurfaceView es establecer el modo de renderización para que solo dibuje la vista cuando haya un cambio en los datos de dibujo con el GLSurfaceView.RENDERMODE_WHEN_DIRTY parámetro de configuración:

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

Este parámetro de configuración evita que el fotograma GLSurfaceView se vuelva a dibujar hasta que llama a requestRender(), que es más eficiente para esta app de ejemplo.

Cómo compilar una clase de procesador

La implementación de la clase GLSurfaceView.Renderer, o renderizador, dentro de una aplicación que usa OpenGL ES es donde todo comienza a ponerse interesante. Esta clase controles lo que se dibuja en el objeto GLSurfaceView con el que está asociado. Existen tres métodos en un procesador que llama el sistema Android para averiguar qué y cómo dibujar en un GLSurfaceView:

• onSurfaceCreated(): Se llama una vez para configurar el entorno OpenGL ES de la vista.
• onDrawFrame(): Se llama por cada volver a dibujar la vista.
• onSurfaceChanged(): Se llama si cambia la geometría de la vista, por ejemplo, cuando cambia la orientación de la pantalla del dispositivo.

Esta es una implementación muy básica de un procesador OpenGL ES, que no hace más que dibujar un fondo negro en 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);
    }
}

Eso es todo. Los ejemplos de código anteriores crean una aplicación para Android simple que muestra una pantalla negra con OpenGL. Si bien este código no hace nada muy interesante, cuando creas estas clases, sentaste las bases que necesitas para comenzar a dibujar elementos gráficos con OpenGL

Nota: Quizás te preguntes por qué estos métodos tienen un parámetro GL10 cuando usas las APIs de OpenGL ES 2.0. Estas firmas de método simplemente se reutilizan para las APIs 2.0 a fin de mantener el código del framework de Android sea más simple.

Si conoces las APIs de OpenGL ES, ahora deberías poder configurar OpenGL ES de tu app y comenzar a dibujar gráficos. Sin embargo, si necesitas un poco más de ayuda comenzaron con OpenGL, continúa con las siguientes lecciones para obtener más sugerencias.