Portage du moteur Bullet Physics d'Android sur une architecture Intel®

| Ilya Krjukov | Denis Smirnov |

Traducteur

Lana Bauer

Les commentaires et les suggestions d'amélioration sont les bienvenus, alors, après votre lecture, n'hésitez pas. Commentez .

- Titre : Portage du moteur Bullet Physics d'Android sur une architecture Intel®

- Auteurs : Ilya Krjukov, Denis Smirnov

- Traducteur : Lana Bauer

- Parution : 15 septembre 2014

- Licence : Copyright ® 2014 Intel. Aucune reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents, images, etc. sans l'autorisation expresse de l'auteur. Sinon vous encourez selon la loi jusqu'à trois ans de prison et jusqu'à 300 000 € de dommages et intérêts.

Sommaire

- I. Introduction

- II. Bullet Physics

- III. Préparation

- IV. Compilation

- V. Portage

- VI. Conclusion

- VII. Ressources

- VIII. À propos des auteurs

I - Introduction

Désormais, il est possible de réaliser des jeux mobiles avec de superbes graphismes et une physique réaliste grâce à la puissance de calcul toujours plus grande des appareils mobiles. Les effets tels que les explosions de grenades dans les jeux de tir et les dérapages de voiture dans les simulateurs de course sont fournis par le moteur physique, dont le cœur est la simulation de la physique. Typiquement, la simulation physique détermine la performance du moteur de jeux. Le succès d'un jeu dépend souvent de la rapidité et de la précision du calcul du modèle physique par le moteur physique.

Cet article vous montre comment compiler et porter la version Android du moteur Bullet Physics sur la plate-forme Intel® Atom™.

II - Bullet Physics

La bibliothèque Bullet Physics est un moteur physique à temps réel et est utilisée dans de nombreux jeux vidéo, des films, des systèmes de modélisation 3D, en tant que composant d'autres moteurs de jeux et d'autres applications [http://bulletphysics.org]. Une version prenant en charge le système Android (ARM optimisé NEON) a été publiée mi-2011.

Nous avons d'abord exécuté une application Bullet Physics sur un Samsung Galaxy Tab 3 10.1 muni d'un processeur basé sur ARM et affichant 30 images par seconde (FPS). Nous avons ensuite porté la même application Bullet Physics sur l'architecture x86. Nous avons exécuté l'application de Bullet Physics sur le même Samsung Galaxy Tab 3 10.1, embarquant maintenant un processeur x86 Intel et affichant 60 FPS. Nous avons comparé les performances de chacun en utilisant les analyseurs de performance graphiques d'Intel [http://software.intel.com/en-us/vcsource/tools/intel-gpa].

En portant des applications sur l'architecture x86, les développeurs gagnent une fenêtre supplémentaire en budget de temps, en augmentant la vitesse de calcul de la physique dans leur jeu, afin qu'ils puissent passer plus de temps sur des graphismes plus réalistes ou sur plus de mouvement dans leurs jeux.

III - Préparation

Pour construire et porter Bullet, nous avons besoin de :

- Android SDK [https://developer.android.com/sdk/index.html] ;

- Android NDK [https://developer.android.com/tools/sdk/ndk/index.html] ;

- Eclipse ADT [https://developer.android.com/sdk/installing/bundle.html] ;

- Bullet Physics [https://bullet.googlecode.com/files/bullet-2.80-rev2531.zip].

Le processus tout entier peut être exécuté sur Windows, Linux ou Mac OS ; fondamentalement, le test sur Linux et Mac OS ne diffère pas de celui sur Windows. Les tests ont été exécutés sur Lenovo K900 et Samsung Galaxy Tab 3 10.1. Les deux appareils sont basés sur le processeur Intel Atom Z2460.

Un script qui effectue automatiquement toutes les actions décrites dans cet article est joint.

IV - Compilation

Compiler et exécuter l'application d'exemple PfxApp_1_Simlpe sous ARM comme première étape.

Figure 1. L'application exemple PfxApp_1_Simple (appareil : Samsung Galaxy* tab 3 10.1)

On construira par la suite la bibliothèque PfxLibrary, le composant principal du moteur physique et pour ce faire, on accède au répertoire du projet de la bibliothèque :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxLibrary\jni.

<BulletPhysics> est le chemin vers le dossier bullet-2.80-rev2531. On ouvre le fichier Android.mk à partir de ce dossier et on remplace la variable déjà déclarée comme suit :

LOCAL_PATH := <BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects

Ensuite, on ouvre la console et on se dirige vers :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxLibrary

On exécute la commande :

ndk-build

Succès ! On vient de construire PfxLibrary pour armeabi-v7a.

Pour construire l'application exemple, on se dirige vers le dossier :

<BulletPhysics>\bullet-2.80-ev2531\Extras\PhysicsEffects\project\Android\PfxApp_1_Simple\jni

On ouvre le fichier Android.mk et on remplace la déclaration :

LOCAL_PATH := <BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects

Dans l'invite de commande, on change dans le dossier du projet :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxApp_1_Simple

Puis on exécute la commande :

ndk-build

Nous utilisons l'IDE Eclipse pour lancer l'application. Importons le projet dans Eclipse :

File => Import => Android => Existing Android Code Into Workspace => Browse… =>

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxApp_1_Simple\

=> OK => Finir

On exécute l'application d'exemple : un clic droit avec la souris sur l'icône du projet et on sélectionne :

Run As => Android Application, comme illustré sur la Figure 2.

Figure 2. Lancer l'application depuis l'IDE Eclipse

L'exemple s'exécutera en mode translation.

V - Portage

Portons l'exemple PfxApp_1_Simple sur x86. On commence par la bibliothèque PfxLibrary et on se dirige vers le dossier du projet :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxLibrary\jni

On ouvre le fichier Android.mk et on change la déclaration :

APP_ABI := x86

On applique ces changements sur le fichier Android.mk :

LOCAL_PATH := <BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects
LOCAL_CFLAGS := $(LOCAL_C_INCLUDES:%=-I%) -DUSE_PTHREADS -pthread
LOCAL_ARM_NEON := false

On élimine les fichiers d'assemblage d'ARM optimisés NEON par suppression de ces lignes de la liste de déclaration LOCAL_SRC_FILES :

src/base_level/solver/pfx_constraint_row_solver_neon.cpp \
include/vecmath/neon/vectormath_neon_assembly_implementations.S

On recompile le moteur physique et dans l'invite de commande, on change le dossier de travail :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxLibrary

On exécute ndk-build. On vient maintenant de construire PfxLibrary pour l'architecture x86 et on répète ces actions pour le portage de l'application d'exemple. On se dirige vers le dossier du projet :

<BulletPhysics>\bullet-2.80-ev2531\Extras\PhysicsEffects\project\Android\PfxApp_1_Simple\jni.

On ouvre le fichier Application.mk et on remplace la déclaration :

APP_ABI := x86

On change les variables du fichier Android.mk :

LOCAL_PATH := \bullet-2.80-rev2531\Extras\PhysicsEffects
LOCAL_SRC_FILES := project/Android/PfxLibrary/obj/local/x86/libpfxlibrary.a
LOCAL_CFLAGS := $(LOCAL_C_INCLUDES:%=-I%)
LOCAL_ARM_NEON := false

On supprime ces lignes des LOCAL_SRC_FILES :

sample/test_ARM_NEON_performance/neon_dot_product.S \
sample/test_ARM_NEON_performance/neon_cross_product.S \
sample/test_ARM_NEON_performance/neon_matrix4_operator_multiply.S \
sample/test_ARM_NEON_performance/neon_matrix3_operator_multiply.S \
sample/test_ARM_NEON_performance/neon_orthoInverse_transform3.S \
sample/test_ARM_NEON_performance/neon_transform3_operator_multiply.S \
sample/test_ARM_NEON_performance/neon_transpose_matrix3.S \
sample/test_ARM_NEON_performance/test_neon_cross_product.cpp \
sample/test_ARM_NEON_performance/test_neon_dot_product.cpp \
sample/test_ARM_NEON_performance/test_neon_matrix3_operator_multiply.cpp \
sample/test_ARM_NEON_performance/test_neon_matrix4_operator_multiply.cpp \
sample/test_ARM_NEON_performance/test_neon_orthoInverse_transform3.cpp \
sample/test_ARM_NEON_performance/test_neon_transform3_operator_multiply.cpp \
sample/test_ARM_NEON_performance/test_neon_transpose_matrix3.cpp \
sample/test_ARM_NEON_performance/test_neon_solve_linear_constraint_row.cpp

On change le dossier de travail pour le dossier du projet :

<BulletPhysics>\bullet-2.80-rev2531\Extras\PhysicsEffects\project\Android\PfxApp_1_Simple

On construit le projet en utilisant la commande ndk-build, puis on exécute l'exemple sur l'appareil.

On utilise l'application APK Info de Google Play pour visualiser les architectures supportées :

[https://play.google.com/store/apps/details?id=com.intelloware.apkinfo].

Figure 3. Captures d'écran de APK Info (appareil : Lenovo K900)

VI - Conclusion

Cet article fournit, étape par étape, les instructions pour la construction et le portage du moteur physique, Bullet Physics. Le résultat d'un portage réussi de l'application sur une architecture x86 fournit une accélération de 2x pour la portion physique de l'application et l'amélioration du nombre d'images par secondes (FPS).

VII - Ressources

Intel Developer Zone Android

Article Original (Anglais)

Porting Low-Level Parts of Android* Native Applications to Intel® Architecture-based Platforms

Intel for Android* Developers Learning Series #7: Creating and Porting NDK-based Android* Applications for Intel® Architecture

Creating and Porting NDK based Android* Apps for IA

Porting OpenGL* Games to Android* on Intel® Atom™ Processors (part 1)

Porting OpenGL* Games to Android* on Intel® Atom™ Processors (part 2)

VIII - À propos des auteurs

Ilya Krjukov (ilya.krjukov@intel.com) - Ingénieur senior en logiciels.

Denis Smirnov (denis.smirnov@intel.com) - Stagiaire en logiciels.