2D/3D Graphics Java and OpenGL context Android /3

Échange et collaboration‎ > ‎Pages d'auditeurs‎ > ‎

2D/3D Graphics Java and OpenGL context Android /3

Jeux dans android 2D et 3D untilisant openGL

Le jeu vidéo(1):

Un jeu vidéo, c'est le rassemblement d'une idée, d'un programme, de dessins et de sons. Ce tout constitue un jeu vidéo. Ces domaines sont eux aussi fragmentés en sous-ensembles : Programmeur, Graphiste, Son.

Le Java est un langage de choix, car couramment utilisé tout en étant simple. De plus, ce langage est privilégié pour faire un jeu pour Android.

Faire des jeux sur Android(1) :

Faire un jeu sur Android est facile. Faire un grand jeu pour un téléphone portable, le multitâche, souvent multi-core, multi-usages système comme Android est plus délicate.

Development d’un jeu 2D sur Android(2):

Exemple: Dessin des sprites à l'écran en utilisant OpenGL. Cette methode fonctionne sur Nexus One de Google , Acer Iconia A500 , et le Samsung Galaxy Nexus .

Vue d'ensemble:

Cette partie détaille comment configurer l’application avec OpenGL. On pourra prolonger les classes OpenGL et mettre en œuvre un moteur de rendu.

Pour créer le premier sprite 2D pour l’application android en utilisant OpenGL ES, il faudra créer quatre composants:

Activité
Voir surface
Renderer
Sprite

Activité Principal:

Les points ci-dessous cite en détail ce qui se passe dans l'exemple de code

Contenir une référence à des SurfaceView
Demander que la demande va plein écran
Instancier la SurfaceView qui passe l'activité au constructeur
Définir les activités en vue de la SurfaceView

Les méthodes OnPause et onResume sont remplacées pour permettre l'appel de la OnPause points de vue et méthodes onResume aussi.

package com.twp.devquest.one;

import android.app.Activity;

import android.os.Bundle;

import android.view.Window;

import android.view.WindowManager;

public class DevQuest1Activity extends Activity {

private DevQuestGLSurfaceView mGLView;

@Override

public void onCreate(Bundle savedInstanceState) {

super.onCreate(savedInstanceState);

requestWindowFeature(Window.FEATURE_NO_TITLE);

getWindow().setFlags(WindowManager.LayoutParams.FLAG_FULLSCREEN,

WindowManager.LayoutParams.FLAG_FULLSCREEN);

mGLView = new DevQuestGLSurfaceView(this);

setContentView(mGLView);

}

@Override

protected void onPause() {

super.onPause();

mGLView.onPause();

}

@Override

protected void onResume() {

super.onResume();

mGLView.onResume();

}

Surface View:

Cela va créer une référence au rendu et va définir le convertisseur des vues comme moteur de rendu client.

Tenir une référence au rendu
Instancier rendu
Régler la surface en mode de rendu au moteur de rendu

package com.twp.devquest.one;

import android.content.Context;

import android.opengl.GLSurfaceView;

public class DevQuestGLSurfaceView extends GLSurfaceView {

private DevQuestGLRenderer mRenderer;

public DevQuestGLSurfaceView(Context context) {

super(context);

mRenderer = new DevQuestGLRenderer(context);

setRenderer(mRenderer);

}

Renderer:

Il s'agit de la section importante, mais sans les autres, elle serait inutile. Le moteur de rendu prend soin de mettre en place la scène pour qu’elle soit prête pour la projection orthographique, ce qui permet la création de références aux sprites pour enfin les dessiner.

variables, contexte, rapport, screenwidth, screenHeight - utilisé plus tard
enregistrer une référence au contexte d'applications - utilisé plus tard
SurfaceCreated - méthodes GL a préparer pour les sprites 2D
SurfaceChanged - recréer la matrice de projection, régler la taille de viewport
onDrawFrame - Fonction de dessin en utilisant le modèle de matrix

package com.twp.devquest.one;

import javax.microedition.khronos.egl.EGLConfig;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.opengl.GLSurfaceView;

public class DevQuestGLRenderer implements GLSurfaceView.Renderer {

private Context context;

private float ratio;

private int screenWidth, screenHeight;

DevQuestGLRenderer(Context context){

this.context = context;

}

@Override

public void onSurfaceCreated(GL10 gl, EGLConfig confid) {

gl.glEnable(GL10.GL_TEXTURE_2D);

gl.glShadeModel(GL10.GL_SMOOTH);

gl.glClearColor(0.098f, 0.525f, 0.933f, 1.0f);

gl.glClearDepthf(1.0f);

gl.glHint(GL10.GL_PERSPECTIVE_CORRECTION_HINT, GL10.GL_NICEST);

gl.glEnable(GL10.GL_BLEND);

gl.glDisable(GL10.GL_DEPTH_TEST);

gl.glBlendFunc(GL10.GL_SRC_ALPHA, GL10.GL_ONE_MINUS_SRC_ALPHA);

}

@Override

public void onSurfaceChanged(GL10 gl, int width, int height) {

// prevent 0 divise

if(height == 0) { height=1;}

screenWidth = width; screenHeight = height;

ratio = (float) width/height;

gl.glMatrixMode(GL10.GL_PROJECTION);

gl.glLoadIdentity();

gl.glOrthof(0, width, 0, height, -10f, 10f);

gl.glViewport(0, 0, screenWidth, screenHeight);

}

@Override

public void onDrawFrame(GL10 gl) {

gl.glClear(GL10.GL_COLOR_BUFFER_BIT | GL10.GL_DEPTH_BUFFER_BIT);

gl.glMatrixMode(GL10.GL_MODELVIEW);

gl.glLoadIdentity();

}

Ce qu’on doit avoir maintenant c’est un écran bleu vide affichée à l'écran. La on a réussi à étendre les classes requises OpenGL et mise en œuvre le thread de rendu (renderer).

Sprites de dessin OpenGL: la creation d’une classe de sprite et comment imprimer ces sprites a l’ecran

Dans cette partie: montrer comment dessiner des sprites à l'écran.

D'abord créer la classe sprite de base qui agira en tant que classe primaire pour tous les sprites qui vont etre ajouter à l'écran dans le futur.

Ajouter l'image ci-joint aux res / drawable / dossier. Il devrait y avoir deux copies de ce fichier:

devquest_1.png
devquest_2.png

Le code comprend une position de place de position pour l'animation

Sprite Base

créer un array de sommets qui représentent le sprite
créer un array de texture pour vertex (coordonnées UV)
allouer, donner l'ordre et stocker le sommet et UV dans un float buffer

Utilisé lors de la méthode draw pour dessiner les bandes de triangles

import java.nio.ByteBuffer;

import java.nio.ByteOrder;

import java.nio.FloatBuffer;

import javax.microedition.khronos.opengles.GL10;

public class DevQuestSpriteBase {

// texture and verts

protected FloatBuffer vertexBuffer, textureBuffer;

ByteBuffer bb;

protected float vertices[] = {

0f,0f,-1f,

1f,0f,-1f,

0f,1f,-1f,

1f,1f,-1f

};

protected float texture[] = {

0.0f, 1.0f,

1.0f, 1.0f,

0.0f, 0.0f,

1.0f, 0.0f,

};

public DevQuestSpriteBase(){

// vertices buffer

bb = ByteBuffer.allocateDirect(vertices.length * 4);

// … code to put vertices and positions

bb.order(ByteOrder.nativeOrder());

// texture buffer and more code for buffer

bb = ByteBuffer.allocateDirect(texture.length * 4);

}

public void draw(GL10 gl){

gl.glEnableClientState(GL10.GL_VERTEX_ARRAY);

gl.glEnableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

gl.glVertexPointer(3, GL10.GL_FLOAT, 0, vertexBuffer);

gl.glTexCoordPointer(2, GL10.GL_FLOAT, 0, textureBuffer);

gl.glDrawArrays(GL10.GL_TRIANGLE_STRIP, 0, vertices.length / 3);

gl.glDisableClientState(GL10.GL_VERTEX_ARRAY);

gl.glDisableClientState(GL10.GL_TEXTURE_COORD_ARRAY);

}

Ball Sprite:

Pour cet exemple, on va montrer comment ajouter une image d'une balle à l'écran. On va étendre la classe de base et ajouter des fonctions supplémentaires, qui sont spécifiques à la "sprite balle".

public class DevQuestSprite extends DevQuestSpriteBase {

// les fonctions de la balle vont apparaitre ici ensuite

}

“Sprites” Class:

Avec un peu de jeu, on a envie de plusieurs sprites à l'écran, c'est pourquoi on créé une catégorie distincte de Sprites. Cette classe contient une liste de tableau du sprite balle et appelle la fonction draw sur eux tous.

import java.io.IOException;

import java.io.InputStream;

import java.util.ArrayList;

import javax.microedition.khronos.opengles.GL10;

import android.content.Context;

import android.graphics.Bitmap;

import android.graphics.BitmapFactory;

import android.opengl.GLUtils;

import android.util.Log;

public class DevQuestSprites {

float screenWidth, screenHeight, wRatio, hRatio;

private int textureCount = 2; // frame animation

private int[] textures = new int[textureCount]; // frame animation

public ArrayList<DevQuestSprite> sprites = new ArrayList<DevQuestSprite>();

private DevQuestSprite tempSprite;

public DevQuestSprites(float screenWidth, float screenHeight){

updateScreenData(screenWidth, screenHeight);

}

public void updateScreenData(float screenWidth, float screenHeight){

// takes screen Height and Width

}

public void addSprite(float x, float y){

tempSprite = new DevQuestSprite();

// code to set x and y

sprites.add(tempSprite);

}

public void draw(GL10 gl){

gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[0]);

for(int loop=0; loop<sprites.size(); loop++){

gl.glPushMatrix();

try {

DevQuestSprite sprite = sprites.get(loop);

// sprite.gravitate(screenHeight); // used later for animation

// code to calculate height and width

gl.glTranslatef(transx, transy, 0.0f);

sprite.draw(gl);

} catch (NullPointerException e) {

}

gl.glPopMatrix();

}

public void loadTextures(GL10 gl, Context context){

InputStream is[] = new InputStream[textureCount];

Bitmap bitmap[] = new Bitmap[textureCount];

// code for setting the array

}

gl.glGenTextures(textureCount, textures, 0);

for(int loop = 0; loop < textureCount; loop++){

gl.glBindTexture(GL10.GL_TEXTURE_2D, textures[loop]);

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MAG_FILTER, GL10.GL_LINEAR);

gl.glTexParameterf(GL10.GL_TEXTURE_2D, GL10.GL_TEXTURE_MIN_FILTER, GL10.GL_LINEAR);

GLUtils.texImage2D(GL10.GL_TEXTURE_2D, 0, bitmap[loop], 0);

bitmap[loop].recycle();

}

Modifications apportées aux fichiers existants:

Maintenant que les nouvelles classes sont déclarées, on aura besoin de faire quelques changements pour le moteur de rendu (Rendering) et l'affichage de surface avant que les sprites ne soient dessinés à l'écran. Les extraits de code ci-dessous comprennent la ligne dont on a besoin de trouver ainsi que la nouvelle ligne de code qui a été inséré.

Renderer:

Il faudra ajouter une référence à la nouvelle classe de collection sprite:

private int screenWidth, screenHeight;

// new line: reference to Sprites Class

public DevQuestSprites sprites;

Instancier les objets sprites et charger les textures à l'intérieur de la méthode onSurfaceChanged:

gl.glViewport(0, 0, screenWidth, screenHeight);

// new lines: initialize variable and load textures

sprites = new DevQuestSprites(width, height);

sprites.loadTextures(gl, context);

Push et pop de la matrice vue modèle, dans la méthode onDrawFrame alors qu’on met a l’echelle la matrice par 10 (facilité de dimensionnement des sommets sur toutes les tailles d'écran) et d'appelerla methode de dessin de sprites

gl.glLoadIdentity();

// new lines: push, scale, draw, pop

gl.glPushMatrix();

gl.glScalef((screenWidth)/10, (screenHeight*ratio)/10, 1.0f);

sprites.draw(gl);

gl.glPopMatrix();

Surface View:

Pour des fins de test, on sera en mesure d'ajouter des sprites à l'écran en touchant l'écran.

@Override

public boolean onTouchEvent(MotionEvent event) {

switch(event.getAction()){

case MotionEvent.ACTION_DOWN :

mRenderer.sprites.addSprite(event.getX(), event.getY());

break;

}

return true;

}

Si tout a été fait correctement, on doit avoir quelque chose qui ressemble à l'image ci-joint lorsque ca arrive à fonctionner. En appuyant sur n'importe quel point de l'écran, on a un nouveau ballon.

Animer les Sprites: comment ajouter du mouvement aux balles

On va expliquer comment aller sur l'ajout d'animation pour les boules dans l'application OpenGL créés jusqu'à présent.

Sprite Class:

Pour commencer, on met à jour la classe existante Sprite:

public class DevQuestSprite extends DevQuestSpriteBase {

// animation variables

public float x, y, initPos, finalPos, initSpeed, currentPos;

// …

// animation functions

//

// gravitate function makes the object travel with respect to gravity

public void gravitate(float screenHeight){

stageHeight = screenHeight;

if(still){ return; }

if(falling){

moveBallDown();

} else if(rising){

moveBallqaUp();

} else {

startFalling();

}

private void startFalling(){

//code for setting time and position

moveBallDown();

}

private void stopFalling(){

falling = false;

if(finalPos-initPos<24){

stopRising();

still = true;

} else {

startRising();

}

private void stopRising(){

rising = false;

}

private void startRising(){

rising = true;

initSpeed = (float) (decay * Math.sqrt(2*Math.abs(finalPos-initPos)));

timer = 0;

currentPos = y;

moveBallUp();

}

private void moveBallDown(){

timer++;

y = initPos + 0.5f*gravity*(timer*timer);

checkBounceBottom();

}

private void moveBallUp(){

timer++;

float posA=y;

y = currentPos - initSpeed*timer + 0.5f*gravity*(timer*timer);

float posB=y;

checkBounceTop(posA, posB);

}

private void checkBounceBottom(){

if(y > stageHeight - 24){

finalPos = y;

stopFalling();

}

private void checkBounceTop(float firstPos, float secondPos){

if(secondPos > firstPos){

stopRising();

startFalling();

}

Sprites Class:

Une ligne importante a été commentée dans la classe DevQuestSprites:

DevQuestSprite sprite = sprites.get(loop);

// sprite.gravitate(screenHeight); // used later for animation

Simplement en enlevant le commentaire de la ligne qui appelle la méthode de sprite gravitate, l’animation se déroulera lors de la prochaine construction de l’appliccation Android OpenGL ES.

sprite.gravitate(screenHeight); // used later for animation

Android tutorial: OpenGL base de développement de jeux 3D (4)

comment créer un projet Eclipse qui contient unesurface OpenGL (GLSurfaceView) .
Sur cette surface, rendre un modèle 3D d'un cube
faire tourner l'objet sur l'écran.

Le projet est composé de 3 classes:

Une Activité: SpinningCube.java
Un Renderer: CubeRenderer.java
Un modèle 3D: Cube.java

Le modele 3D Cube.java

Cette classe contient toutes les données du modèle 3D: le cube.

Dans le développement de jeux, les angles sont appelés sommets. Si vous regardez dans la classe java, on voit qu'il ya un tableau de vertex.

La derniere matrice est appelé indices. Ce tableau contient les coordonnees x, y, z pour les 12 lignes.

byte indices[] = {
0, 4, 5, 0, 5, 1,

1, 5, 6, 1, 6, 2,

2, 6, 7, 2, 7, 3,

3, 7, 4, 3, 4, 0,

4, 7, 6, 4, 6, 5,

3, 0, 1, 3, 1, 2
};

Après cela le cube est initialisé en plaçant la matrice dans des buffers. Les buffers seront utilisés pour créer un objet OpenGL.

Le (Cube)Renderer:

Le rendu est essentiellement là où le jeu est en boucle. Les methodes utilisees:

onDrawFrame : une mise à jour des objets / repeindre l'écran (ce qui est la boucle de jeu)
onSurfaceChanged : Est appelé lorsque l’appareil est incline et l'écran doit etre redimensionner (portrait / paysage)
onSurfaceCreated : Initialiser le moteur de rendu (renderer)

La methode onDrawFrame est la plus importante. C'est là ou tout le mouvement / Physique / rotation etc etc est fait.

Simplement en enlevant le commentaire de la ligne qui appelle la méthode de sprite gravitate, l’animation se déroulera lors de la prochaine construction de l’appliccation Android OpenGL ES.

sprite.gravitate(screenHeight); // used later for animation

Android tutorial: OpenGL base de développement de jeux 3D (4)

comment créer un projet Eclipse qui contient une surface OpenGL (GLSurfaceView) .
Sur cette surface, rendre un modèle 3D d'un cube
faire tourner l'objet sur l'écran.

Le projet est composé de 3 classes:

Une Activité: SpinningCube.java
Un Renderer: CubeRenderer.java
Un modèle 3D: Cube.java

Le modele 3D Cube.java

Cette classe contient toutes les données du modèle 3D: le cube.

Dans le développement de jeux, les angles sont appelés sommets. Si vous regardez dans la classe java, on voit qu'il ya un tableau de vertex.

La derniere matrice est appelé indices. Ce tableau contient les coordonnees x, y, z pour les 12 lignes.

byte indices[] = {
0, 4, 5, 0, 5, 1,

1, 5, 6, 1, 6, 2,

2, 6, 7, 2, 7, 3,

3, 7, 4, 3, 4, 0,

4, 7, 6, 4, 6, 5,

3, 0, 1, 3, 1, 2
};

Après cela le cube est initialisé en plaçant la matrice dans des buffers. Les buffers seront utilisés pour créer un objet OpenGL.

Le (Cube)Renderer:

Le rendu est essentiellement là où le jeu est en boucle. Les methodes utilisees:

onDrawFrame : une mise à jour des objets / repeindre l'écran (ce qui est la boucle de jeu)
onSurfaceChanged : Est appelé lorsque l’appareil est incline et l'écran doit etre redimensionner (portrait / paysage)
onSurfaceCreated : Initialiser le moteur de rendu (renderer)

La methode onDrawFrame est la plus importante. C'est là ou tout le mouvement / Physique / rotation etc etc est fait.

Appareils Android utilisant 2D et 3D

Versions Android(1):

Android a commencé sa phase bêta en Novembre 2007 et a ensuite évolué pour Android 1.5 Cupcake donnant son prénom dessert. Il prend en charge les touches virtuelles, dictionnaire utilisateur, des widgets, et de lecture vidéo mpeg-4 et formats 3GP et interfaces utilisateur les plus élémentaires. Puis le développement est venu avec la popularité qui grandit ainsi, l'évolution Android 1.6 Donut à, 2,0 Eclair, 2.2 Froyo et 2.3 Gingerbread.

Après avoir eu la stabilité dans les téléphones mobiles, Android 3.0 est né dans les tablettes qui offrent la technologie exclusive et un soutien à de tels dispositifs. Puis, récemment, le Sandwich 4.0 Ice Cream et 4,1 Jellybean a amélioré le système et a ajouté des fonctionnalités nouvelles telles que la reconnaissance des visages. Android prend en charge les smartphones, tablettes, appareils et certaines portable-comme des dispositifs tels que le Chromebook.

1ere Version Android supportant 3D : Honeycomb (2)

La plate-forme Android 3.0 introduit de nombreuses fonctionnalités nouvelles et passionnantes pour les utilisateurs et les développeurs. Ce document donne un aperçu de quelques-unes des nouvelles fonctionnalités et technologies, tel que livré dans Android 3.0.

Nouvelle interface utilisateur conçue dès le départ pour les tablettes

Android 3.0 est une nouvelle version de la plate-forme Android qui est spécifiquement optimisé pour les appareils avec des écrans plus grands, en particulier des comprimés.

Android 3.0 s'appuie sur les choses que les gens aiment le plus à propos de Android - raffiné multitâche, les notifications riches, la personnalisation écran d'accueil, des widgets, etc - et les transforme avec une dynamique, une expérience 3D et l'interactivité profonde, ce qui les rend familier, mais encore mieux qu'avant.

Les applications écrites pour Android 3.0 sont capables d'utiliser un ensemble étendu d'objets d'interface utilisateur, graphiques puissantes et des capacités des médias pour engager les utilisateurs de nouvelles manières.

Des performances graphiques 2D et 3D

Nouvelle animation cadre

La plate-forme comprend un cadre d'animation flexible qui permet aux développeurs de facilement animer les propriétés d'éléments d'interface tels que les vues, Widgets, Fragments, drawables, ou tout autre objet arbitraire.

Accélération matérielle des graphismes 2D

Android 3.0 offre une nouvelle accélération matérielle OpenGL renderer qui donne un gain de performances pour de nombreuses opérations courantes de graphiques pour les applications en cours d'exécution dans le cadre d'Android. Lorsque le rendu est activée, la plupart des opérations en toile, Peinture, Xfermode, ColorFilter, Shader, et la caméra sont accélérés. Les développeurs peuvent contrôler la façon dont l'accélération matérielle est appliquée à tous les niveaux, de l'activer à l'échelle mondiale dans une application pour permettre aux activités spécifiques et des vues à l'intérieur de l'application.

RenderScript moteur graphique 3D

RenderScript est un cadre d'exécution en 3D qui offre à la fois une API pour la construction de scènes 3D ainsi qu'un spécial language Shader, une plate-forme indépendante pour des performances maximales. En utilisent renderScript, on peut accélérer les opérations graphiques et de traitement des données. RenderScript est un moyen idéal pour créer des effets de haute performance pour les applications 3D, fonds d'écran, des carrousels, et plus encore.

Téléphones Android 3D(3):

- N ° 1 HTC EVO 3D - Top 5 des smartphones 3D :

HTC a Android 2.3 Gingerbread et D33P, une application de conversion photo 2D en 3D, qui a été développé spécialement avec cet appareil à l'esprit. Il permet de convertir des photos Facebook à la 3D.

- Galapagos 3D Image courtoisie (Softbank 003SH) de l'utilisateur de Flickr TAKA @ PPRS

- Avec l'Optimus 3D, LG mise aussi sur les smartphones à écran 3D

- Sharp Nouveau sans lunettes 3D Smartphone Android est livré avec 8- mégapixels à double lentille Cam

Tablettes Android(4)

En septembre 2010, Samsung présente le Samsung Galaxy Tab, tournant sous Android 2.2 (FroYo) et sortie fin 2010.

Motorola a présenté au CES 2011 la Xoom, première tablette bénéficiant de la nouvelle version du système mobile de Google, Honeycomb (Android 3.0). S'ensuivent de nombreuses tablettes sous Android Honeycomb proposées par un très large choix de constructeurs, dont Samsung, Acer, ASUS, Toshiba et Sony.

Là aussi, Android a été porté sur d'autres appareils comme la HP TouchPad, le portage a été réalisé début 2012 avec la version 9 de CyanogenMod, basé sur Ice Cream Sandwich, et fin 2011 avec la version 7 de CyanogenMod basé sur Gingerbread^.

En juillet 2012, Google lance en partenariat avec Asus pour fabriquer la Nexus 7, tablette multimédia low-cost et première tablette de Google.

3 mois plus tard, la Nexus 10, tablette 10 pouces fabriquée par Samsung a été présenté en même temps que le Nexus 4 fabriqué, lui, par LG. Elle propose une définition d'écran record pour une tablette (2560 x 1600 pixels)

Tablette 3D sans lunettes:

Gadmei, une jeune société chinoise déjà à l’origine de la tablette de jeu compatible 3D sans lunettes la Wikipad, a dévoilée durant le CES qui a récemment fermé ses portes deux tablettes 3D sans lunettes : La T863 et la E8-3D
La Bosma E8, une tablette “Made in China” qui possède un écran capable d’afficher la 3D sans lunettes.

Conclusion

L'affichage en relief est encore loin d'avoir envahi le quotidien. Alors qu'elle est désormais courante dans les salles de cinéma, cette technique de projection en relief stéréoscopique peine à se généraliser sur les autres écrans(1)

Interrogés par CNET, des représentants de LG et Samsung estiment que l'affichage 3D n'en est qu'à ses premiers pas. Et si cette technologie est encore assez rare dans l'univers des smartphones, celle-ci devrait s'imposer dans les années à venir grâce à l'amélioration régulière de leurs performances(1)

Selon LG et Samsung, les téléphones pourront par exemple prendre des photos enrichies et laisser le soin à l'utilisateur d'opter pour un affichage en 2D ou en 3D. Idem pour les vidéos. L'affichage en relief doit aussi apporter une nouvelle expérience à l'utilisateur, avec une immersion plus importante au sein de jeux ou d'applications(1)

À l'heure actuelle, quelques smartphones supportent déjà la projection d'images en relief stéréoscopique. C'est le cas du LG Optimus 3D mais aussi du japonais Sharp. Ces appareils s'appuient sur la technologie auto-stéréoscopique, qui permet de percevoir l'effet de relief sans savoir recours à des lunettes spéciales(1)

Voici trois prédictions de l'avenir de l'Android en 2013(2):

Le premier est le projet de verre qui est encore l'objet de recherches et de développement de Google. Il s'agit d'un visiocasque ou HMD avec les informations smartphone comme le format. L'appareil exécute le système d'exploitation Android de Google. Le HMD permet à l'utilisateur d'accéder à certaines fonctionnalités des smartphones tels que des applications, recherche d'images et de reconnaissance de visage. Les sources d'entrée peuvent être sous forme de texte, texte à la parole, le signal audio, et peut-être plus.

La deuxieme Prédiction c’est les Smartphones Flexi qui sont actuellement l'objet de recherches et de développement dans plusieurs entreprises de haute technologie - LG, Samsung et Sony. Le raisonnement derrière la création de téléphones flexibles provient de matériaux de son affichage et les objectifs pour éviter les bris dans des situations comme étant renforcé par inadvertance ou d'une situation. Divers ensembles de différents types d'écrans seront utilisés par les trois sociétés qui offrent des écrans flexibles enroulables et pliable. Android sera le premier système d'exploitation pour exécuter les téléphones flexibles.

Enfin, la prochaine nouvelle version 5.0 Android Key Lime Pie. La nouvelle version est encore en développement et confirmée par un employé de Google que ce firmware sera publié dans le courant de mai 2013. LG va peut-être etre l'une des premières marques de libérer un smartphone fonctionnant avec Key Lime Pie et Optimus G2 est le dispositif soupçonné de l'avoir.

Et il ne s'arrête pas là, Android 5.0 Key Lime Pie en mai, le LG Optimus G2 en mai, et un autre téléphone Nexus est également répandu pour être libéré en mai ainsi. Certes, ces événements futurs frapperont mai 2013.

Comments