Différence entre 2D et 3D
La différence entre les images 3D et 2D est que les images 3D
ajoutent la perception de la profondeur, le monde qui nous entoure n'est pas à deux dimensions, mais riche
avec la profondeur. Tandis qu'une image en 2D n'a qu'une hauteur et une largeur, et les objets sur la
photo sont à plat. Les applications 2D peuvent utiliser des techniques 3D pour obtenir
des effets tels que l'éclairage, et 3D peuvent utiliser des techniques de rendu 2D. Les termes «en trois dimensions» (3D ou 3-D) et "deux
dimensions" (2D ou 2-D) sont utilisés en référence à la photographie et d'autres technologies de l'image
graphique, tels que l'animation et l'infographie. 3D est utilisé pour décrire un objet physique comme un mobile, ce qui pourrait être décrit comme l'art tridimensionnel, en comparaison avec une peinture à deux dimensions. Une image en trois dimensions ne peut être créée sans dupliquer
l'effet de deux yeux travaillent en tandem, ce qui permet des effets tridimensionnels perceptifs tels que
la perception de profondeur. La technologie 3D possède des configurations à double caméra ou
double objectif, et la technologie informatique moderne peut facilement créer des effets réalistes à
la fois 2D et 3D.La photographie des dossiers d'images pour la reproduction sur le
plat, en deux dimensions des surfaces, telles que les impressions papier ou des
écrans d'affichage ont pour effet d'aplatir l'image, réduire ou éliminer l'effet de profondeur. La
vision naturelle produit cet effet parce que les yeux sont légèrement écartées, permettant au cerveau de
traiter les deux points de vue différents de la même image. Au cours de la fin du 19e siècle, les
photographes ont tenté de remédier à ce problème avec deux caméras fixes et en mouvement qui ont été
conçus pour fonctionner en tandem. OpenGL est une interface de programmation d'application (API) qui permet aux applications logicielles d'interagir avec du matériel graphique et de créer en trois dimensions (3D) des scènes rapidement et efficacement, et en deux dimensions (2D) les techniques de programmation. L'accélération matérielle fournie par la bibliothèque peut améliorer la performance et, la facilité du logiciel de programmation qui n'est pas nécessairement appel à des modèles 3D ou des transformations. La vue OpenGL spécifiquement pour la 2D: D'abord un GLSurfaceView.Renderer, le rendu devra ensuite être affecté à la GLSurfaceView. Cette dernière est une interface générique, qui a trois fonctions abstraites qui sont les suivantes:
1) onDrawFrame: Cette méthode est appelée par le fil
d'OpenGL pour dessiner la trame courante. public void onDrawFrame(GL10 gl10) {
// Just clear the screen and depth buffer. gl10.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); //... other gl calls to render the scene ...
} 2) onSurfaceChanged: Cette méthode est utilisée lorsque la surface change de taille, et appelée après que la surface est créée et chaque fois que OpenGL ES change la surface de taille.
public void onSurfaceChanged(GL10 gl10, int width, int height) {
gl10.glViewport(0, 0, width, height); /* * Définir notre matrice de projection. Cela ne doit pas être effectuée à chaque fois que nous * Dessine, mais en général, une nouvelle projection doit être réglé lorsque la fenêtre * Est redimensionnée. */
3) onSurfaceCreated: Cette méthode est utilisée lorsque la surface est créé ou recréé. Ici, nous allons mettre en place les couleurs par défaut OpenGL et les paramètres de rendu. Et appelé lorsque le thread de rendu commence et chaque fois que le contexte EGL est perdu. Le contexte EGL sera généralement perdu lorsque l'appareil Android se réveille après d'aller dormir. Étant donné que cette méthode est appelée au début de la fonte, ainsi que chaque fois que le contexte EGL est perdu, cette méthode est un endroit pratique pour placer le code pour créer des ressources qui doivent être créés lorsque le rendu commence, et qui ont besoin d'être recréé lorsque le contexte EGL
est perdu. Les textures sont un exemple d'une ressource que vous
pouvez créer ici. public void onSurfaceCreated(GL10 gl10, EGLConfig eglConfig) {
gl10.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_FASTEST); // Set the background color to black ( rgba ). gl10.glClearColor(0.0f, 0.0f, 0.0f, 1); gl10.glShadeModel(GL10.GL_FLAT); gl10.glDisable(GL10.GL_DEPTH_TEST); // Définir OpenGL pour optimiser les textures 2D gl10.glEnable(GL10.GL_TEXTURE_2D);
// Désactiver 3D des caractéristiques spécifiques. gl10.glDisable (GL10.GL_DITHER); gl10.glDisable(GL10.GL_LIGHTING); gl10.glTexEnvx(GL10.GL_TEXTURE_ENV, GL10.GL_TEXTURE_ENV_MODE, GL10.GL_MODULATE); // Initial clear of the screen. gl10.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT); }
Création d'une application OpenGL:
SurfaceView est un type particulier de vue qui est utilisé pour les
graphismes 3D.
Surface est une place pour le dessin, comme une toile, sauf qu'il est mis en œuvre par le matériel 3D. La surface sera créée lors de votre activité OpenGL est exécuté en premier plan, et détruite lors de la sortie d'activité ou de toute autre activité vient au premier plan. SurfaceHolder est une instance de cette classe est toujours là, même si la surface qu'il occupe va suite. SurfaceHolder.Callback est un SurfaceView implémente cette interface afin OpenGL lui notifier lorsque la surface de la vue est créé, supprimé, ou redimensionnés.
Mélange graphique de 2D et 3D L'application existante qui produise des images en 2D dans lequel chaque rafraîchissement de l'écran via l'API 2D produit une nouvelle image 2D. Ces images peuvent ensuite être copié dans un OpenGL ES texture pour permettre au ce dernier (OpenGl ES) de l'afficher sur l'écran. OpenGL ES peuvent ensuite animer le mouvement de l'ensemble de l'image comme une texture en appliquant une transformation pour créer un effet de transition d'une image de l'écran à l'autre. Cet effet de transition peut être animé d'une rotation, l'échelle vers le haut ou vers le bas, de traduire, apparaître ou disparaître, ou n'importe quelle combinaison. La géométrie de la texture pour obtenir ces effets peuvent être aussi simples que d'une paire de triangles pour former un rectangle qui correspond à la forme de l'écran. La durée des effets d'animation est généralement juste une fraction de seconde, juste assez longtemps pour que l'utilisateur visualise l'animation et de fournir une expérience 3D mais pas assez pour empêcher l'interface utilisateur. Lorsque les animations sont terminées, le cycle se répète. OpenGL ES est efficace à l'animation des textures après avoir été chargé, parce que l'accélération 3D ne fait la plupart du travail. L'exemple de code ci-dessous présente les principales étapes à suivre pour initialiser OpenGL ES 2.0 pour effectuer une transition animée (l'échelle et rotation) d'une image de texture 2D. Tout d'abord, un ombrage GL ES Langue shaders programme est sélectionné pour une utilisation par le ShaderHandle, et les emplacements de ses uniformes sont récupérés. Ensuite, deux matrices sont créées pour une projection en perspective simple: la matrice de projection et la matrice de vue du modèle. Ensuite, une texture est créée et chargée d'une image 2D en utilisant la glTexImage2D conventionnel () méthode.
L'image sera mappée sur une paire de triangles qui forment un rectangle, de sorte que les pointeurs vers le sommet et les attributs de coordonnées de texture sont transmis au shader avec glVertexAttribPointer (). Ces tableaux de même pour la paire de triangles seront réutilisés pour chaque image de l'animation, mais la position du rectangle sur l'écran est recalculée à chaque itération de la boucle. La boucle commence par effacer le tampon de trames vers le noir. Ensuite, le fModelViewMartix est recalculé pour la prochaine image de l'animation et transmise au shader avec glUniformMatrix4fv (). Le fProjectionMatrix utilisé est le même pour chaque trame. Enfin, l'appel à glDrawArrays () initialise le rendu de l'image de texture sur la paire de triangles par l'accélérateur OpenGL ES *. L'appel à eglSwapBuffers () rend la nouvelle trame rendue visible à l'écran. Exemple d'une transition texture animée: #include "GLES2/gl2.h"
Lors de l'ajout d'OpenGL ES pour une application existante en 2D, le principal point de discorde est la propriété du frame buffer. Le frame buffer est spécial, car il est la zone de mémoire qui est réellement affiché sur l'écran (par opposition à hors écran tampons). OpenGL ES s'attend à acquérir le frame buffer du pilote EGL, qui acquiert des pointeurs vers le frame buffer de l'appareil Linux frame buffer.
Votre API 2D est probablement rendu à la mémoire frame buffer alloué même de ce même périphérique Linux frame buffer. C'est le conflit.
Android est un bon exemple de ceci: Il possède le frame buffer. Android a des caractéristiques 2D qui sont déjà intégrées avec OpenGL ES, ce qui est très bien pour une nouvelle application à partir de zéro. Dans le cas contraire, le défi est de rendre l’héritage API 2D sans posséder le frame buffer.
Différence entre OpenGL et OpenGL ES
OpenGL (Open Graphics Library) est une inter-langue, multi-plate-forme API pour le rendu de l'infographie 2D et 3D. L'API est généralement utilisée pour interagir avec un GPU, pour obtenir l'accélération matérielle du rendu. La spécification OpenGL décrit une API abstraite pour dessiner des graphiques 2D et 3D. Bien qu'il soit possible de l'API à mettre en œuvre entièrement dans le logiciel, il est conçu pour être mis en œuvre principalement ou entièrement dans le matériel. Par exemple, la mise en œuvre de Microsoft Windows OpenGL exécute toutes ses commandes de rendu en utilisant un GPU.
L'API est définie comme un certain nombre de fonctions qui peuvent être appelées par le client programme, avec un certain nombre de constantes entières nommées (par exemple, le GL_TEXTURE_2D constante, qui correspond au nombre décimal 3553). Bien que les définitions de fonctions soient superficiellement semblables à ceux du langage de programmation C, ils sont indépendants de la langue. En tant que tel, OpenGL a des liens linguistiques très nombreux, certains des plus remarquables étant le Javascript contraignant WebGL, la liaison C fournis par iOS, et les liaisons Java et C prévus par Android.
En plus d'être indépendant de la langue, OpenGL est également indépendant de la plateforme. La spécification ne dit rien au sujet de l'obtention et la gestion, un contexte OpenGL, laissant cela comme un détail du système de fenêtrage sous-jacent. Pour la même raison, OpenGL est uniquement préoccupé de rendu elle ne fournit aucune API liées à l'entrée, de l'audio ou de fenêtrage. C'est peut-être la plus grande différence entre OpenGL et son concurrent, DirectX. OpenGL est une API en constante évolution. Les nouvelles versions de la spécification OpenGL sont régulièrement publié par le Khronos Group, dont chacun s'étend de l'API pour appuyer diverses nouvelles fonctionnalités. Les détails de chaque version sont décidés par consensus entre les membres du groupe, y compris les fabricants de cartes graphiques, les concepteurs de systèmes d'exploitation, et les entreprises technologiques généraux tels que Mozilla et Google.
En plus des fonctionnalités requises par l'API de base, les fournisseurs de GPU peut fournir des fonctionnalités supplémentaires sous la forme d'extensions. Les extensions peuvent introduire de nouvelles fonctions et de nouvelles constantes, et peuvent atténuer ou à supprimer les restrictions sur les fonctions OpenGL existantes. Les fournisseurs peuvent utiliser des extensions pour exposer les API personnalisée sans avoir besoin de l'appui de d'autres fournisseurs ou Khronos Group dans son ensemble, ce qui augmente considérablement la flexibilité de l'OpenGL. La première version d'OpenGL, version 1.0, a été publiée en Janvier 1992. Depuis lors, OpenGL a parfois été étendue en libérant une nouvelle version de la spécification. Ces communiqués de définir un ensemble de base des caractéristiques qui toutes les cartes graphiques conformes doivent prendre en charge, et contre laquelle de nouvelles extensions peuvent plus facilement être écrite. Chaque nouvelle version d'OpenGL tend à intégrer un certain nombre d'extensions qui ont un large soutien parmi les fournisseurs de cartes graphiques, bien que les détails de ces extensions puissent être modifiés.
On note quelque extesion d'openGL 1.1 :
EXT_vertex_array : Plusieurs sommets peuvent être transmis à la GL avec un seul appel de fonction. EXT_polygon_offset : Valeurs de profondeur peuvent être compensés sur une base par-primitive. EXT_texture_object : Etat texture peut être stocké dans un objet GL, pour plus d'efficacité.
OPENGL 1.2: Une caractéristique notable d’OpenGL 1.2 est l'introduction du sous-ensemble d'imagerie. Il s'agit d'un ensemble de fonctionnalités qui sont très utiles pour les applications de traitement d'images, mais qui ont une utilité limitée ailleurs. La mise en œuvre de ce sous-ensemble a toujours été facultative, le soutien est indiquée par la publicité de la chaîne de ARB_imaging extension. OPENGL 1.2.1: Opengl 1.2.1 est une version mineure, apparaissant seulement sept mois après la sortie de la version 1.2. Il introduit le concept d'extensions ARB, et défini le ARB_multitexture extension, sans encore l'incorporer dans la spécification de base OpenGL. OPENGL 1.3 : ARB_texture_compression: Un cadre standard sur lequel formats de texture comprimé peut être pris en charge, sans nécessiter de support de la compression réelle. La spécification OpenGL 2.0 inclut le support de GLSL(OpenGL Shading Language). OpenGL 3.0 a introduit un mécanisme de dépréciation pour simplifier les futures révisions de l'API. La dernière version d’OpenGL 4.3 a ajouté:
OpenGL ES pour les systèmes embarqués est un sous-ensemble de l'interface graphique 3D OpenGL de programmation d'application (API) conçue pour les systèmes embarqués tels que les téléphones mobiles, les PDA et les consoles de jeux vidéo. Plusieurs versions de la spécification OpenGL ES existent maintenant. OpenGL ES 1.0 est dressé contre l'OpenGL 1.3, OpenGL ES 1.1 est défini par rapport à la spécification OpenGL 1.5 et OpenGL ES 2.0 est définie par rapport à la spécification OpenGL 2.0. Cela signifie que, par exemple, une application écrite pour OpenGL ES 1.0 devrait être facilement portable vers l'ordinateur de bureau OpenGL 1.3, comme OpenGL ES est une version allégée de l'API, l'inverse peut ou peut ne pas être vrai, en fonction de la caractéristiques particulières utilisées.
OpenGL ES 1.0 Une différence significative entre OpenGL et OpenGL ES est que OpenGL ES éliminé la nécessité de support OpenGL appelle à glBegin et glEnd. D'autres différences importantes sont que la sémantique d'appel pour fonctions de rendu primitifs a été modifiée en faveur des vertex arrays, et en virgule fixe les types de données ont été introduites pour les coordonnées des sommets. Attributs ont été ajoutés afin de mieux soutenir les capacités de calcul des processeurs embarqués, qui manquent souvent d'une unité à virgule flottante (FPU). De nombreuses autres fonctions et des primitives de rendu ont été supprimés dans la version 1.0 afin de produire une interface légère, y compris:
OpenGL ES 1.1 OpenGL ES 1.1 ajouté des fonctionnalités telles que le support obligatoire pour multitexture, un meilleur soutien multitexture (y compris les multiplexeurs et les points opérations texture des produits), automatique mipmap génération, Vertex Buffer Objects, les requêtes étatiques, plans de coupe d'utilisateur et un meilleur contrôle de rendu par points.
OpenGL ES 2.0 OpenGL ES 2.0 a été publié en Mars 2007. Basé sur environ OpenGL 2.0, il élimine mais la plupart du pipeline de rendu à fonction fixe en faveur d'un programmable, dans un mouvement similaire à transition de l'OpenGL 3.0 à 3.1.le flux de contrôle est généralement limité à transmettre de branchement et de boucles où le nombre maximum d'itérations peut facilement être déterminés au moment de la compilation. Presque toutes les fonctionnalités de rendu de la transformation et de pipelines d'éclairage, tels que la spécification des matériaux et des paramètres de lumière anciennement spécifié par la fonction API fixe, sont remplacés par des shaders écrites par le programmeur graphique. En conséquence, OpenGL ES 2.0 n'est pas compatible avec OpenGL ES 1.1. OpenGL ES 2.0 est aussi "agnostique" en ce qui concerne l'impartialité du système de coordonnées, bien que le comportement par défaut soit gaucher. OpenGL est également gaucher en interne, mais les matrices de projection dans l'API de pipeline fixe, n'est pas disponible en OpenGL 2.0 ES, convertir à un système de coordonnées main droite. Les autres incompatibilités entre la version de bureau de l'OpenGL et OpenGL ES 2.0 persisté jusqu'à OpenGL 4.1, qui ajoute GL_ARB_ES2-compatibilité.
OpenGL ES 1.1 et OpenGL ES 2.0 sont des sous-ensembles de la norme OpenGL standard. Lorsqu’on utilise l'API OpenGL ES, il y a des limites qu'on doit être conscient lors de l'élaboration des applications. Par exemple, les fonctionnalités suivantes OpenGL n'est pas présent dans les deux OpenGL ES 1.1 et OpenGL ES 2.0:
OpenGL ES 3.0 La spécification OpenGL ES 3.0 a été publiée en Août 2012. OpenGL ES 3.0 est rétro-compatible avec OpenGL ES 2.0, permettant aux applications de progressivement ajouter de nouvelles fonctionnalités à des applications visuelles.
|
 | |
|
|