OpenGL

Android incluye soporte para alto rendimiento en 2D y gráficos 3D con la biblioteca de gráficos abierta (OpenGL), en concreto, la API OPENGL es una api de gráficos de plataforma cruzada que esepcifica una interfície de programario estándar para el maquinario de proceso de gráficos 3D. OPENGL es una adaptación de la especificación OpenGL destinada a dispositivos encastados.

Android es compatible con varias versiones de la API OpenGL.

Es una api que especifica como se hacen los modelos 3D... hay un jugador que mira al mundo, todo esta compuesto por triángulos, las matrices de trabajo están perfectamente definidas, forma parte de kronos, lo hicieron para los sistemas 3D.

Kronos es una fundación con ánimo de lucro, todo es libre pero se ganan dinero por el hardware. Se creó en lenguaje C, es de estado secuencial y trabaja matricialmente, era un c sin complicaciones porque estaba pensado para código máquina. La gracia es que el algoritmo de cálculo de una superficie la puede hacer o bien el hardware y si este no lo tiene implementado lo hace el software.

Entonces si tienes un programa que tiene que hacer iluminación, hay que tener en cuenta que el hardware es mucho más rápido que usar el software.

Hay varias versiones, estas hacen referencia al OpenGL a dispositivos móviles, el webGL es con javascript con navegador y unicamente OpenGL para los PCs de mesa, como Windows, Linux, Apple...

Las diferentes y más relevantes versiones de OpenGL serian:

• OpenGL ES 1.0 y 1.1 - especificación API con soporte de android 1.0 y superior.
• OpenGL ES 2.0 - especificación API soportado por Android 2.2 (nivel de API 8) 4.3 y superior.
• OpenGL ES 3.0 - especificación API con soporte para android (nivel de API 18) 4.3 y superior.

L'API especifica proporcionada por Android es similar a la API J2ME JSR239 OpenGL ES, pero no es idéntica.

Hay dos clases fundamentales en Android que te permite crear y manipular gráficos con la API OpenGL ES:

• GL.SurfaceView.
• GL.SurfaceView.Renderer.

GL.SurfaceView

Esta clase es una View donde se puede dibujar y manipular objetos mediante llamadas a la API de OpenGL y es similar en función a un  . Se puede utilizar esta clase mediante la creación de una instancia de GLSurfaceView y añadiendo su Renderer en ella. No obstante, si queremos capturar desarrollos de pantalla táctil, se ha de ampliar la clase. GLSurfaceView para implementar los oyentes táctiles.

El GLSurfaceView es una vista especial que gestiona superficies OpenGL para nosotros y dibuja en el sistema de visión de Android. También añade una gran cantidad de características que hacen que sea más fácil de usar OpenGL, incluyendo pero no limitado a:

• Proporciona un subproceso de representación dedicada para OpenGL porque no afecte al fin principal.
• Nos permite dibujar siempre que queramos.
• Se ocupa de la configuración de pantalla para nosotros, utilizando EGL, la interfície entre OpenGL y el sistema de ventanas subyacente.

Esencialmente tendremos una vista, igual que tenemos botones, imagenes y textView, tendremos un GLSurfaceView, todo lo que se dibuje ahí irá por hardware. Para utilizar OpenGL se recomiendan las APIS de java, OpenGL esta especificado en C, pero son cáculos matriciales por lo tanto no hay centenares de líneas de código, sino que son productos transformados que pueden llevar a cualquier lenguaje de programación. Con cualquier lenguaje de programación puedes hacerlo.

GLSurfaceView.Renderer

Aquesta interfície define los métodos necesarios para dibujar gráficos en un GLSurfaceView. Se tiene que proporcionar una implementación de esta interfície con una clase separada y adjuntarla a la instancia GLSurfaceView utilizando GLSurfaceView.setRenderer().

Requiere que implemente los métodos siguientes:

• onSurfaceCreated(): El sistema llama a este método una vez, en crear el GLSurfaceView. Utilizad este método para llevar acciones que tienen que ocurrir solamente una vez, como configurar los parámetros del entorno OpenGL o el inicio de objetos gráficos OpenGL.
• onDrawFrame(): El sistema llama a este método en cada redibujo del GLSurfaceView. Utilizad estos métodos como principal punto de ejecución para elaborar (y redibujar) objetos gráficos.
• onSurfaceChanged(): El sistema llama a este método cuando los GLSurfaceView cambian de geometría, incluyendo cambios en el tamaño del GLSurfaceView o la orientación de la pantalla del dispositivo. Por ejemplo el sistema que llama a este método cuando el dispositivo cambia de vertical a horizontal. Utilizad este método para responder los cambios en el GLSurfaceView contenedor.

 Si la aplicación utiliza funciones de OpenGL que no estan disponibles en todos los dispositivos tiene que incluir estos requisitos dentro del archivo AndroidManifest.xml:
<uses-feature android:glEsVersion="0x00020000" android:required="true" />
<uses-feature android:glEsVersion="0x00030000" android:required="true" />
API OpenGL ES 3.0 es compatible con la 2.0, lo que significa que puede ser mas flexible con su implementación de OpenGL ES en la aplicación. Declarar OpenGL 2.0 es un requisito, y al comprobar la disponibilidad de la API 3.0 en tiempo de ejecución, si es compatible, utilizará esta.
Ejemplo de  código:

@Override
public void onCreate(Bundle savedInstanceState)
   {
   super.onCreate(savedInstanceState);
   mGLSurfaceView = new GLSurfaceView(this);
   // soporta OpenGL ES 2.0?
   final ActivityManager activityManager = (ActivityManager)
   getSystemService(Context.ACTIVITY_SERVICE);
   final ConfigurationInfo configurationInfo = activityManager.getDeviceConfigurationInfo();
   final boolean supportsEs2 = configurationInfo.reqGlEsVersion >= 0x20000;
   if (supportsEs2){
      // contexto compatible
      mGLSurfaceView.setEGLContextClientVersion(2);
      mGLSurfaceView.setRenderer(new NuestroRenderer());
   } else{
      // Usar OpenGL ES 1, por ejemplo
   }
   //utilizamos toda el area de la activity
   setContentView(mGLSurfaceView);
}

Antes de que nuestro procesador muestre algo, necesitamos algo que mostrar. En OpenGL ES 2, especificamos matrices de nombres. Estos números pueden representar posiciones, colores, o cualquier otra cosa. En esta demo mostraremos tres triángulos.

// Los datos estan guardados en buffer de tipo float.
private final FloatBuffer mTriangle1Vertices;
private final FloatBuffer mTriangle2Vertices;
private final FloatBuffer mTriangle3Vertices;
//nombre de bytes per float
private final int mBytesPerFloat = 4;
//Inicialitzatció.
public NuestroRenderer(){
   final float[] triangle1VerticesData= {
      // X, Y, Z,
      // R, G, B, A
      -0.5f, -0.25f, 0.0f,
      1.0f, 0.0f, 0.0f, 1.0f,

      0.5f, -0.25f, 0.0f,
      0.0f, 0.0f, 1.0f, 1.0f,

      0.0f, 0.559016994f, 0.0f,
      0.0f, 1.0f, 0.0f, 1.0f
   }
   // Inicialización de los buffers.
   mTriangle1Vertices = ByteBuffer.allocateDirect(triangle1VerticesData.length *    mBytesPerFloat).order(ByteOrder.nativeOrder()).asFloatBuffer();
   ...
   mTriangle1Vertices.put(triangle1VerticesData).position(0);
   ...
}

Es normal que la codificación este en Java en Android, pero la implementación interna de OpenGL ES 2 esta escrita en C. Antes de pasar nuestros datos por OpenGL, tenemos que convertirlo a un formato que se puedan entender. Java y el sistema operativo nativo podría no guardar sus bytes en el mismo orden, así que hace falta utilizar un conjunto especial de clases de amortiguación y crear un ByteBuffer suficientemente grande como para mantener, entre nuestros datos, y decirle que para guardar los datos utilizando la orden de bytes nativo. Entonces los convertimos en un FloatBuffer, para que podamos hacerlo servir para guardar los datos de punto flotante. Finalmente, copiamos nuestra matriz en la memoria intermedia.

Apuntes.
Ejemplo.