Dessiner des objets géométriques

Pour rappel, les primitives supportées sous OpenGL sont les points, lignes, polygones, triangles, ...

Vertex Array

Pour dessiner des objets géométriques, une solution consiste à passer les vertice, mais aussi les couleurs, coordonnées du brouillard, ... via un ou des tableaux à la carte graphique.

L'avantage de cette solution étant de fournir un plus grand nombre d'informations en un minimum d'appel.

• Mais pour pouvoir utiliser ces tableaux, il faudra d'abord activer (puis désactiver) OpenGL pour qu'il utilise les dits tableaux.

  C'est le rôle de static void glEnableVertexAttribArray(int index) dans la classe GLES20

  En entrée:

  index correspond à l'index d'un attribut du vertex shader qui traitera le tableau.

   

  La fonction void GLES20.glDisableVertexAttribArray(int index); désactivera OpenGL pour l'utilisation du tableau par l'attribut d'index index.

   

• Ensuite, il faut indiquer à OpenGL où se trouve les tableaux

  static void glVertexAttribPointer(int index, int size, int type, boolean normalized, int stride, Buffer ptr) toujours dans la classe GLES20

  En entrée:

  index correspond à l'index d'un attribut du vertex shader qui traitera le tableau.

  size: correspond aux nombres d'éléments composant un vertex (3 pour les éléments x, y et z), ...

  type: type utilisé par les éléments (exemple GLES20.GL_FLOAT pour indiquer un élément de type float

  normalized: demander ou non à normaliser les données (true ou false)

  stride: taille qu'occuppe effectivement un vertex, ... Par exemple si les coordonnées d'un vertex sont composées de x, y et z qui sont de type float, stride sera 3 * 4 octets (un float occupant 4 octets)

  ptr: pointeur sur le tableau.

   

Il ne reste plus qu'à demander à dessiner le tableau:

public static void glDrawArrays (int mode, int first, int count);

En entrée:

mode: primitives supportées sous OpenGL sont les points, lignes, polygones, triangles, ...

first: Indique l'index de départ à utiliser dans les tableaux activés.

count: le nombre de vertice à traiter.

Exemple de code

En reprenant les exemples de codes pour Shader, FactoryShader, ProgramGLSL et sa Factory, les codes suivants vont permettre de dessiner un rectangle à l'écran !!!

De plus, les 3 fichiers .xml sont identiques à ceux déjà créés pour initialiser OpenGL...

Un MainActivity:

package fr.free.supertos; import android.app.Activity; import android.app.ActivityManager; import android.content.Context; import android.content.pm.ConfigurationInfo; import android.opengl.GLSurfaceView; import android.os.AsyncTask; import android.os.Bundle; import android.util.Log; import android.view.Menu; public class MainActivity extends Activity { //! OpenGL SurfaceView public GLSurfaceView mGLSurfaceView=null; private MaTacheDeFond maTache; @Override protected void onCreate(Bundle savedInstanceState) { super.onCreate(savedInstanceState); ActivityManager am = (ActivityManager) getSystemService(Context.ACTIVITY_SERVICE); ConfigurationInfo info = am.getDeviceConfigurationInfo(); Log.d ("OPENGL SE", "Version " + info.reqGlEsVersion); // Ok, OpenGL SE 2.0 ou plus installé if (info.reqGlEsVersion >= 0x20000) { Log.d ("OPENGL SE", "=>On peut y aller !"); mGLSurfaceView = new MonGLSurfaceView(this); setContentView(mGLSurfaceView); } else { // Incompatible, affichage d'un écran standard qui indique le problème. setContentView(R.layout.activity_main); } } @Override protected void onPause() { super.onPause(); if (mGLSurfaceView != null) { mGLSurfaceView.onPause(); maTache.cancel(true); } } @Override protected void onResume() { super.onResume(); if (mGLSurfaceView != null) { mGLSurfaceView.onResume(); Log.d ("Debug !!!", "Ma tache de fond : execute !"); maTache=new MaTacheDeFond(); maTache.execute(); } } @Override public boolean onCreateOptionsMenu(Menu menu) { // Inflate the menu; this adds items to the action bar if it is present. getMenuInflater().inflate(R.menu.main, menu); return true; } class MaTacheDeFond extends AsyncTask<Void, Long, Void> { @Override protected void onPreExecute() { } @Override protected void onProgressUpdate(Long... values){ // Progression de la barre if (mGLSurfaceView!=null) mGLSurfaceView.requestRender(); Log.d ("onProgressUpdate", "relance renderer..."); } @Override protected Void doInBackground(Void... arg0) { // Si le thread vient a être interrompu, alors stop traitement if (!isCancelled()) { try { Thread.sleep (1000); } catch (InterruptedException e) { // TODO Auto-generated catch block e.printStackTrace(); } // Traitement long...En principe, il devrait aussi y avoir un test isCancelled() dans ce long traitement ! } return null; } @Override protected void onPostExecute(Void result) { } @Override protected void onCancelled() { } } }

Dont les explications seront identiques au chapitre initialiser OpenGL.

La seule différence sera l'utilisation d'une classe MonGLSurfaceView qui n'a rien d'extraordinaire, et qui étend GLSurfaceView:

package fr.free.supertos; import android.content.Context; import android.opengl.GLSurfaceView; import android.util.Log; public class MonGLSurfaceView extends GLSurfaceView { private static final String MONGLSURFACEVIEW = "MonGLSurfaceView"; private GLES20Renderer renderer; public MonGLSurfaceView(Context context) { super(context); this.setEGLContextClientVersion(2); // On associe un renderer comprenant le GLES20 ... renderer = new GLES20Renderer(); this.setRenderer(renderer); } @Override public void onPause() { super.onPause(); } @Override public void onResume() { super.onResume(); } }

Et le renderer associé à MonGLSurfaceView

package fr.free.supertos; import static android.opengl.GLES20.GL_COLOR_BUFFER_BIT; import static android.opengl.GLES20.glClear; import static android.opengl.GLES20.glClearColor; import static android.opengl.GLES20.glViewport; import java.util.ArrayList; import java.util.List; import javax.microedition.khronos.egl.EGLConfig; import javax.microedition.khronos.opengles.GL10; import android.opengl.GLES20; import android.opengl.GLSurfaceView.Renderer; import android.util.Log; public class GLES20Renderer implements Renderer { public final static String GLES20RENDERER = "GLES20Renderer"; Shader s1Vertex=null; Shader s1Fragment=null; private ProgramGLSL p1GLSL=null; private Triangle mTriangle; private final String vertexShaderCode = "attribute vec4 aPosition;\n" + "void main() {" + " gl_Position = aPosition;" + "} "; private final String fragmentShaderCode = "precision mediump float;" + "void main() {" + " gl_FragColor = vec4 (0,0,0,0);" + "}"; @Override public void onDrawFrame(GL10 gl10) { // Log.d ("Renderer", "onDrawFrame..." ); // gl10 inutilisé car nous travaillons en 2.0 glClear(GL_COLOR_BUFFER_BIT); if (mTriangle != null) { mTriangle.draw(); } else { Log.d (GLES20RENDERER, "onDrawFrame inactif, pas de triangle à dessiner."); } } @Override public void onSurfaceChanged(GL10 gl10, int width, int height) { Log.d (GLES20RENDERER, "onSurfaceChanged."); glViewport(0, 0, width, height); } @Override public void onSurfaceCreated(GL10 gl, EGLConfig eglConfig) { Log.d (GLES20RENDERER, "onSurfaceCreated"); glClearColor(1.0f, 0.0f, 0.0f, 1.0f); // Création presque à la main d'un shader vertex s1Vertex= new Shader (GLES20.GL_VERTEX_SHADER); Log.d (GLES20RENDERER, "GL_VERTEX_SHADER création:"+s1Vertex.getError()); // Compilation du shader vertex s1Vertex.compileSourceShader(vertexShaderCode); Log.d (GLES20RENDERER, "GL_VERTEX_SHADER compilation:"+s1Vertex.getError()); if (s1Vertex.getCodeError() == Shader.SHADERNOERROR) { // Pas d'erreur, alors on continue sur le fragment s1Fragment = FactoryShader.FragmentShader(fragmentShaderCode); Log.d (GLES20RENDERER, "Fragment shader:"+s1Fragment.getError() + "=" + s1Fragment.getTailleError()); if (s1Fragment.getCodeError() == Shader.SHADERNOERROR) { // Ok, le fragment est maintenant créé, donc // Création d'une liste de shader List <Shader> listShader=new ArrayList <Shader> (); listShader.add(s1Vertex); listShader.add(s1Fragment); // Que l'on injecte ensuite dans un programme shader ProgramGLSL p1GLSL= FactoryProgramGLSL.genererProgramGLSL(listShader); Log.d (GLES20RENDERER, "Programme shader:"+p1GLSL.getError() + "=" + p1GLSL.getTailleError()); if (p1GLSL.getCodeError() != ProgramGLSL.PROGRAMNOERROR) { // Bug dans le code produit, on arrête tout ! p1GLSL.detruireProgramGLSL(); p1GLSL=null; } // Les shaders sources ne serviront plus maintenant, erreur ou pas ... s1Vertex.deleteShader(); s1Vertex=null; s1Fragment.deleteShader(); s1Fragment=null; // Initialisation d'un triangle if (p1GLSL != null) { Log.d (GLES20RENDERER, "Création d'une instance de triangle"); mTriangle = new Triangle(p1GLSL); } } else { // Si erreur sur fragment shader, pas la peine de continuer ! s1Vertex.deleteShader(); s1Vertex=null; s1Fragment.deleteShader(); s1Fragment=null; } } else { // Si erreur sur vertex shader, pas la peine de continuer ! s1Vertex.deleteShader(); s1Vertex=null; } } }

Dedans seront programmés les shaders et la compilations de ceux-ci.

Et enfin, le plus important par rapport aux explications données ici, une esquisse de classe pour dessiner un objet géométrique, ici un triangle:

package fr.free.supertos; import java.nio.ByteBuffer; import java.nio.ByteOrder; import java.nio.FloatBuffer; import android.opengl.GLES20; public class Triangle { private FloatBuffer vertexBuffer; private static final int NB_VERTEX = 3; // 3 vertice pour un triangle ! private static final int NB_COORDS_PAR_VERTEX = 3; // 3 coordonnées par vertex private static final int BYTES_PER_FLOAT = 4; // Un float occupe 4 octets // Un triangle static float triangleCoords[] = { 0.0f, 1.0f, 0.0f, -1.0f, -1.0f, 0.0f, 1.0f, -1.0f, 0.0f }; private int indexAPosition=0; // Index de l'attribur aPosition private final ProgramGLSL prgGLSL; public Triangle(ProgramGLSL program) { // Création d'un byte buffer ByteBuffer bb = ByteBuffer.allocateDirect(triangleCoords.length * BYTES_PER_FLOAT); // Utiliser l'ordre correspondant à la plateforme bb.order(ByteOrder.nativeOrder()); // creer un buffer de type flottant depuis le ByteBuffer vertexBuffer = bb.asFloatBuffer(); // Et transmission des coordonnées vertexBuffer.put(triangleCoords); // enfin initialiser le pointeur à 0 vertexBuffer.position(0); prgGLSL=program; } public void draw() { int mProgram=prgGLSL.getNumProgram(); // Indiquer les programmes shader à utiliser... GLES20.glUseProgram(mProgram); // Création d'un attribut aPosition à l'index 0 GLES20.glBindAttribLocation(mProgram, 0, "aPosition"); // Récupération de l'index, c'est juste pour l'exemple, puisqu'ici, il est déjà connu ! indexAPosition = GLES20.glGetAttribLocation(mProgram, "aPosition"); // Indiquer que l'attribut va pointer sur un buffer GLES20.glEnableVertexAttribArray(indexAPosition); // Et précision sur la construction du buffer GLES20.glVertexAttribPointer(indexAPosition, // Index de l'attribut NB_COORDS_PAR_VERTEX, // 3 informations par vertex (correspondant à x, y et z) GLES20.GL_FLOAT, // De type float false, NB_COORDS_PAR_VERTEX * BYTES_PER_FLOAT, // La taille occupée en byte par un vertex est donc 3 * taille d'un float vertexBuffer); // Et un pointeur sur le buffer // Ok, on peut dessiner maintenant ! GLES20.glDrawArrays(GLES20.GL_LINE_LOOP, 0, NB_VERTEX); // Disable de l'attribut du vertex array GLES20.glDisableVertexAttribArray(indexAPosition); } }

Dedans sera paramétré le shader vertex et le partage d'une zone mémoire en JAVA et OpenGL tel que déjà expliqué ici.

Ouah, c'est beau !

Bon, ok, il y a mieux !

Annexe

Il s'agit ici d'une première solution pour dessiner des objets graphiques. Il en existe une seconde utilisant la technique des buffers object, vu plus tard. Il faut d'abord voir comment appliquer des couleurs aux vertice...