Introduction à OpenGL dans Android
OpenGL signifie Open Graphics Library. Il s'agit essentiellement d'une API utilisée par l'androïde pour prendre en charge des graphiques haute performance comme les graphiques 2D et 3D. L'utilisation globale d'OpenGL pour transférer les données du CPU vers le GPU. Cela se fait par OpenGL Objects. Il s'agit d'une API graphique multiplateforme. Dans cette rubrique, nous allons découvrir OpenGL dans Android.
Les objets OpenGL sont constitués d'états et de données et sont ceux qui aident à transmettre les données entre le CPU et le GPU. L'OpenGL ES est une spécification populaire de l'API OpenGL qui est spécialement dédiée aux systèmes embarqués.
OpenGL dans Android est pris en charge par Android à l'aide du Kit de développement natif (NDK) et de son API de framework. Les classes fondamentales du cadre Android vous aident à créer et à modifier des graphiques. L'API OpenGL ES utilisée avec ces classes s'appelle GLSurfVaceiew.Renderer et GLSurfaceView. Une bonne compréhension de l'implémentation de ces classes est utile pour utiliser OpenGL dans votre application Android.
GLSurfaceView
Vous pouvez dessiner et manipuler des objets dans cette vue. Il est facile d'utiliser cette classe car vous pouvez créer un objet de GLSurfaceView et y ajouter un moteur de rendu. Vous pouvez capturer des événements d'écran tactile en étendant la classe GLSurfaceView pour implémenter les écouteurs tactiles.
GLSurfaceView.Renderer
L'interface GLSurfaceView.Renderer contient des méthodes requises pour dessiner des graphiques dans une GLSurfaceView. L'implémentation de cette interface doit être fournie en tant que classe distincte attachée à l'instance GLSurfaceView à l'aide de GLSurfaceView.setRenderer () .
Vous devez implémenter les méthodes suivantes pour l'implémentation de l'interface GLSurfaceView.Renderer:
- onSurfaceCreated () : Cette méthode est appelée lors de la création de GLSurfaceView.
- onDrawFrame () : cette méthode est appelée lors de chaque redessin de GLSurfaceView.
- onSurfaceChanged () : Cette méthode est appelée lorsque la géométrie GLSurfaceView change (taille, orientation, etc.).
Comment fonctionne OpenGL dans Android?
Il existe plusieurs types d'objets OpenGL. Par exemple, un objet tampon de sommet qui peut stocker des sommets d'un caractère. Le deuxième exemple est Texture qui peut stocker des données d'image.
Les données telles que les sommets, les normales et les coordonnées UV qui représentent les caractéristiques du maillage sont chargées dans un objet tampon de sommet, puis envoyées au GPU pour traitement. Une fois dans le GPU, ces données passeraient par ce que l'on appelle le pipeline de rendu OpenGL.
Les tâches principales dont Rendering Pipeline est responsable sont la conversion des sommets vers le bon système de coordonnées, l'assemblage des sommets d'un caractère, l'application de la couleur ou de la texture et l'affichage du personnage sur le framebuffer par défaut qui est l'écran.
Le processus de pipeline de rendu d'OpenGL dans Android se compose de six étapes comme ci-dessous:
- Fonctionnement par sommet
- Assemblée primitive
- Traitement primitif
- Rastérisation
- Traitement des fragments
- Opération par fragment
Fonctionnement par sommet
La première et principale étape pour rendre une image est que les données de géométrie doivent être converties d'un système de coordonnées dans un autre système de coordonnées.
Assemblée primitive
Les sommets sont collectés en paires de 2, 3 et plus dans cette étape particulière et la primitive est assemblée, par exemple, un triangle.
Traitement primitif
Une fois les primitives assemblées, elles sont testées pour vérifier si elles relèvent d'un View-Volume. Au cas où ils ne passeraient pas ce test particulier, ils seraient ignorés dans les étapes suivantes. Ce test est connu sous le nom d'écrêtage.
Rastérisation
Ensuite, les primitives sont décomposées en morceaux d'unités plus petites et correspondant à celle des pixels dans le tampon d'image. Chacune de ces petites unités est alors appelée Fragments.
Traitement des fragments
Lorsque la primitive a été pixellisée, la couleur ou la texture est appliquée à la géométrie.
Opération par fragment
Enfin, les fragments sont soumis à différents tests tels que:
- Test de propriété des pixels
- Test de ciseaux
- test alpha
- Test au pochoir
- Test de profondeur
À partir de ces six étapes, deux étapes sont contrôlées par des programmes appelés Shaders.
Shader, en bref, est un petit programme développé par vous seul qui vit dans le GPU. Il existe un langage graphique spécial appelé OpenGL Shading Language (GLSL) dans lequel un shader est écrit. Les deux étapes importantes du pipeline OpenGL où un shader a lieu sont appelées étapes de «traitement par sommet» et de «traitement par fragment».
Le shader traité à l'étape «Per-Vertex» est appelé Vertex Shader. Le shader qui est traité à l'étape «par fragment» est connu sous le nom de Fragment Shader. Le but ultime et fondamental du vertex shader est de donner la transformation finale des sommets du personnage au pipeline de rendu tandis que le fragment shader est de donner les données de coloration et de texture à chacun des en-têtes de pixel au framebuffer.
Lorsque les données sont transmises via le pipeline de rendu OpenGL, le modèle 3D ou 2D apparaîtra sur l'écran de votre appareil.
Programme GL
Conseils pour OpenGL dans Android
Dans le cas où vous êtes un débutant en programmeur OpenGL, certains de ces points ci-dessous peuvent ne pas avoir été rencontrés par vous. Vous trouverez ci-dessous quelques directives à suivre lors de l'utilisation d'OpenGL dans Android. Ce sont des erreurs courantes. Gardez donc toujours cela à l'esprit.
- Mise à l'échelle incorrecte des normales pour l'éclairage
- Une mauvaise pavage blesse l'éclairage
- N'oubliez jamais votre mode Matrix
- Débordement de la pile de matrices de projection
- Ne pas définir tous les niveaux Mipmap
- Lecture des pixels de luminance
Pré-requis pour OpenGL dans Android
Vous trouverez ci-dessous les prérequis requis pour OpenGL dans Android.
Compétences de logiciels
- C, c'est-à-dire le langage de programmation.
- La connaissance du C ++ n'est pas nécessaire mais utile.
- Utilisation de diverses bibliothèques pouvant être statiques ou dynamiques.
Mathématiques
- Connaissance des vecteurs en 2D et 3D.
- Matrices
- Concepts mathématiques de base.
Ce sont tous des concepts principaux et de base qui sont nécessaires pour commencer avec OpenGL. Vous devrez peut-être apprendre d'autres concepts mathématiques, mais après avoir atteint le niveau intermédiaire. Mais cela dépend totalement de vous. Vous pouvez passer de nombreuses choses à l'aide de différentes bibliothèques.
Conclusion: OpenGL dans Android
Par conséquent, OpenGL est une API complètement fonctionnelle qui est de niveau primitif et permet au programmeur d'adresser efficacement et de tirer parti du matériel graphique. Un grand nombre de bibliothèques de haut niveau ainsi que des applications utilisent OpenGL en raison de ses performances, de sa facilité de programmation, de son extensibilité et de sa prise en charge étendue.
Article recommandé
Cela a été un guide pour OpenGL dans Android. Ici, nous avons discuté du processus de travail et des pré-requis d'OpenGL dans Android. Vous pouvez également consulter nos autres articles suggérés pour en savoir plus -
- WebGL vs OpenGL
- Qu'est-ce que Cognos?
- Qu'est-ce que Jira Software?
- Carrière dans Azure