interaction d`un personnage virtuel 3d depuis un pocket pc vers un pc

INTERACTION D’UN PERSONNAGE VIRTUEL 3D DEPUIS
UN POCKET PC VERS UN PC
Projet de Semestre Eté 2002-2003 EPFL, I&C, VRlab
Développé par :
Pascal Porte
Professeur : D. Thalmann
Assistant : M. Gutiérrez
Table des Matières
1
2
3
4
5
6
7
8
INTRODUCTION .................................................................................................1
1.a
Description du Projet .....................................................................................1
1.b
A propos de ce Rapport..................................................................................1
1.c
Les Bases du Projet........................................................................................1
1.d
Logiciels et Outils utilisé pour ce Projet........................................................2
1.e
Déroulement du Projet ...................................................................................2
INTERFACE .........................................................................................................3
2.a
Description de l’Interface ..............................................................................3
2.b
Utilisation.......................................................................................................4
2.c
Problèmes Rencontré .....................................................................................5
ANIMATION ........................................................................................................6
3.a
Personnage Virtuel.........................................................................................6
3.b
Chargement des Animations ..........................................................................6
INTERACTION ....................................................................................................9
4.a
Réseau ............................................................................................................9
4.b
Protocole ........................................................................................................9
PERFORMANCES .............................................................................................11
5.a
Caractéristiques du PDA de Test .................................................................11
5.b
Analyse des Performances ...........................................................................11
CONCLUSION ...................................................................................................13
APPENDICE .......................................................................................................14
7.a
Network.h.....................................................................................................14
7.b
Primities.h ....................................................................................................15
7.c
Class Surface1App.......................................................................................16
7.d
Class Obj......................................................................................................18
REFERENCES ....................................................................................................19
1 INTRODUCTION
1.a Description du Projet
On assiste ces dernières années à la démocratisation des plates-formes
mobiles tel que téléphones et ordinateurs portables, Pockets PCs, … Plus
récemment encore, les réseaux sans fil ont fait leur apparition avec entre
autres les normes BlueTooth et WiFi. Concernant cette dernière, nous avons
vu ces derniers mois de plus en plus de bornes d’accès être installées à
l’EPFL dans le cadre du projet TSF [1].
C’est à partir de ce constat que ce projet a été défini. En effet il a pour but de
mettre en œuvre un système permettant l’interaction d’un personnage virtuel
3D depuis un Pocket PC vers un PC à travers un réseau. Il doit aussi être
possible de jouer des animations extraites depuis des fichiers BAP respectant
la norme MPEG-4 sur l’animation de personnage [2]. Il est aussi important
que l’application finale ait de bonnes performances. Il est à noter que
l’application sur PDA doit aussi pouvoir fonctionner sans être connecté à un
PC.
1.b A propos de ce Rapport
Deux personnes ont travaillé sur ce projet : Pascal Porte et Alexis Touon. Le
travail a été divisé en deux parties distinctes, à savoir la partie Pocket PC et la
partie PC. Concernant ce rapport, il ne fait état que du travail effectué sur le
PDA.
1.c Les Bases du Projet
L’assistant de ce projet, Mario Gutiérrez a, par le passé, fait un projet
similaire à celui-ci [3]. Il avait implémenté un lecteur d’animation MPEG-4
de personnage 3D pour Pocket PC. Mais il y avait plusieurs limitations. En
effet, il n’y avait pas d’interaction possible avec le personnage et il n’était
possible de faire jouer qu’une seul animation : Charleston. De plus les
performances étaient limitées puisque le modèle 3D était composé de 10'000
polygones. Le projet actuel a pour but d’améliorer tous ces points.
-1-
1.d Logiciels et Outils utilisé pour ce Projet
Pour ce projet, plusieurs outils ont été utilisés. Il a d’abord fallu choisir quelle
librairie allait être utilisée pour développer la partie 3D. Il y avait deux choix
possible, Diesel Engine [4] ou PocketGL [5]. C’est finalement Diesel Engine
qui a été choisie, d’une part parce que c’est ce qu’avait utilisé Mario
Gutiérrez dans son précédent projet, et d’autre part parce que la librairie
PocketGL est toujours en développement. De plus, Diesel Engine est un
« clone » de DirectX pour Pocket PC, ce qui permet de pouvoir gérer
aisément le stylet et les touches du PDA. Un autre avantage de cette librairie
est de pouvoir tester l’avancée de l’implémentation directement sur PC, ainsi
il n’est pas nécessaire de transférer le programme sur le PDA pour le tester.
Pour implémenter la partie réseau, c’est la librairie standard Winsock qui a
été choisie.
Pour les outils de développement, le logiciel Microsoft Visual C++ 7 a
largement été utilisé. Pour la compilation pour Windows CE [10] (système
d’exploitation des Pocket PC) et le transfert de l’application sur le PDA, le
logiciel Microsoft eMbedded Visual C++ 3.0 a été utilisé. Ce dernier dispose
d’un émulateur qui permet de tester les programmes pour Pocket PC sans
avoir à les transférer sur un vrai PDA. Malheureusement il n’a pas été
possible de l’utiliser, en effet il semblerait que la librairie Diesel Engine ait
quelques problèmes avec cet émulateur. Mais comme il était justement
possible de tester l’application sur PC, cela n’a pas posé de problèmes.
1.e Déroulement du Projet
Le but du projet étant de faire une interaction entre un PDA et un PC, c’est
l’interface réseau qui a été implémenté dans un premier temps avec la librairie
Winsock.
Ensuite la partie graphique a été implémentée avec la librairie Diesel Engine,
ce qui a permis de mettre en place l’environnement : la lampe, la caméra…
Après cela, c’est la création du modèle 3D du personnage qui a débuté. Il a
été décidé de faire un modèle simplifié du personnage afin de privilégier les
performances. Chaque partie du corps a une forme de prisme, ce qui diminue
considérablement le nombre de polygones par rapport à un modèle réaliste.
Une fois le modèle 3D terminé, c’est l’interaction qui a été implémentée. Il a
donc fallu interfacer le moteur graphique avec les entrées telles que le stylet
et les boutons du PDA.
Enfin, c’est la lecture d’animation qui a été rajoutée à l’application. Cela
permet à la personne qui utilise le PDA de faire jouer au personnage une des
animations disponible dessus.
-2-
2 INTERFACE
2.a Description de l’Interface
Vous pouvez voir sur l’image suivante à quoi ressemble l’interface
graphique :
On peut remarquer plusieurs choses sur l’image précédente. La première,
c’est la simplicité du modèle. Comme il a déjà été dit, cette simplicité est
voulue.
Il est possible de sélectionner une partie du corps pour pouvoir interagir avec.
Lorsqu’une partie du corps est sélectionnée, celle-ci apparaît en jaune.
Dans le coin en haut à gauche, on aperçoit des informations textuelles. La
première ligne indique la vitesse d’affichage en images par seconde, la
deuxième ligne indique le nom du membre sélectionné et enfin la dernière
indique l’animation sélectionnée.
-3-
2.b Utilisation
L’utilisateur a plusieurs moyens pour utiliser l’application, un stylet est bien
sûr à sa disposition, mais il a aussi la possibilité d’utiliser les boutons du
PDA. Voici une image tirée de l’aide de Diesel Engine référençant les
différents boutons utilisables sur un Pocket PC.
On peut remarquer que tous les boutons ne sont pas utilisables.
Voici les fonctions assignées aux différentes combinaisons d’entrées :
o Stylet : l’utilisation du stylet permet à l’utilisateur de faire tourner le
membre sélectionné suivant ses axes x et y,
o DIK_DEVICE0 + Stylet : permet d’interagir avec le personnage en
faisant tourner le membre sélectionné le long de son axe z,
o DIK_DEVICE1 + Stylet : cette combinaison permet de déplacer la
caméra autour du sujet,
o DIK_DEVICE2
: ce bouton permet de quitter l’application,
o DIK_UP
: permet de sélectionner l’élément suivant,
o DIK_DOWN
: permet de sélectionner l’élément précédent,
o DIK _LEFT
: ce bouton sélectionne l’animation précédente,
o DIK_RIGHT
: celui-ci sélectionne l’animation suivante,
o DIK_RETURN
: arrête ou démarre l’animation sélectionnée.
-4-
2.c Problèmes Rencontré
La méthode utilisée pour mettre à jour les angles de l’articulation sélectionnée
en fonction des mouvements du stylet utilise une méthode de la libraire
Diesel Engine. Cette méthode permet de connaître les déplacements du stylet
d’une image à une autre. L’utilisation de cette méthode a apporté quelques
problèmes qu’il a fallu corriger. En effet, quand le stylet était utilisé à un
endroit de l’écran du PDA, des problèmes apparaissaient lorsque le stylet était
levé de l’écran puis réutilisé à un autre endroit de l’écran. Ces problèmes se
manifestaient sous forme de « sauts » durant la rotation du membre
sélectionné. Ce bogue vient du fait que, contrairement à ce que l’on aurait pu
penser, le mouvement du stylet n’est pas nul lorsque celui-ci est déplacé d’un
endroit à un autre de l’écran en étant soulevé. Plus le déplacement du stylet
était grand, plus les valeurs renvoyées pour le déplacement du stylet étaient
grandes et donc en une seule image, l’élément sélectionné était tourné d’un
grand angle ce qui donnait une impression de saut.
Une fois la source du problème trouvée, il fut simple de le résoudre, il a
simplement suffit d’ignorer la première valeur de déplacement du stylet
quand on posait celui-ci sur l’écran, ce qui permet maintenant d’avoir un
fonctionnement normal quelque soit l’utilisation du stylet…
-5-
3 ANIMATION
3.a Personnage Virtuel
Pour des raisons de performance, le modèle du personnage a été adapté. Il est
constitué de 16 parties cubiques: tête, torse, ventre, bassin, bras gauche/droit,
avant bras gauche/droit, main gauche/droite, cuisse gauche/droite, mollet
gauche/droit et enfin pied gauche/droit. Il est possible avec le Diesel Engine
de créer des hiérarchies. Cette possibilité a été utilisée pour constituer le
personnage, chaque partie du corps étant liée avec son parent, sauf le bassin
qui constitue le sommet de la hiérarchie.
Pour les articulations, le centre de gravité des différentes parties a été déplacé
à l’endroit où se trouve le joint avec son parent supérieur. Ainsi, pour
modifier la disposition d’un membre, il suffit juste de modifier son angle de
rotation par rapport à l’angle d’origine. Par exemple, pour le bras, son centre
de gravité a été déplacé au niveau de l’épaule. Ses mouvements de rotations
auront donc pour centre l’articulation de l’épaule.
3.b Chargement des Animations
Une fois l’application lancée, il est possible d’animer le personnage suivant
plusieurs animations pré-enregistrées. Plusieurs animations sont disponibles,
celles-ci sont chargées lorsque le programme démarre. Lors du chargement,
l’application lit les fichiers BAP (Body Animation Parameters) de ces
animations. Ces fichiers d’animations respectent la norme MPEG-4
concernant l’animation de personnage. Un fichier BAP contient les
informations des angles de chaque articulation au cours de l’animation. Il est
ainsi possible d’animer un personnage ayant jusqu’à 296 paramètres. La
majorité des articulations ont 3 paramètres pour leur mouvement, certaines en
ont moins car elles ne peuvent pas s’orienter suivant tout les axes, c’est le cas
par exemple du coude, qui ne peut tourner que suivant un axe.
Un fichier BAP a la structure suivante : chaque image de l’animation est
décrite par deux lignes, la première ligne est un masque, elle est constituée de
0 ou de 1 pour chacun des 296 paramètres. Un 0 signifie que l’angle
concernant ce paramètre est à sa valeur par défaut. Un 1 signifie que, au
contraire, l’angle concernant le paramètre n’a pas la valeur par défaut. Pour
connaître cette valeur, il faut alors aller à la ligne suivante. En effet, cette
ligne contient des valeurs entières qui correspondent aux paramètres qui
avaient un 1 dans le masque.
Dans le masque, l’ordre des paramètres est défini dans la norme. Dans la
deuxième ligne, l’ordre des valeurs entières suit l’ordre d’apparition des 1
dans le masque.
-6-
La transformation des valeurs entières en radians se fait selon la formule
suivante :
angleEnRadian = valeurEntière * π / 100000
Voici un exemple d’un fichier BAP décrivant l’animation ayant une durée
d’une image et contenant de 5 paramètres :
1 1 0 1 0
1542 1542 -3483
Concernant le chargement de l’animation en mémoire après la lecture du
fichier BAP, l’animation est stockée sous forme de tableau à deux
dimensions, avec une ligne pour chaque image et une colonne pour chaque
angle. Afin d’économiser la mémoire, il n’y a que les paramètres
correspondant aux membres du modèle simplifié qui ont été gardé, soit 37
paramètres sur les 296. Les valeurs entières concernant les angles des
paramètres du fichier BAP sont directement transformées en radians durant le
chargement. La valeur par défaut pour les paramètres dont le masque vaut 0
est 0. L’image suivante représente la posture que prend le personnage virtuel
quand ses membres ont leur orientation par défaut :
Lorsque l’application joue une animation, à chaque image, les valeurs des
angles des joints sont mises à jour à l’aide du tableau cité plus haut.
-7-
Plusieurs choix d’animations à jouer sont disponibles. Lors de
l’implémentation, une classe a été créée pour les animations. Ainsi chacune
des animations est un objet, il n’est pas difficile d’en rajouter, il suffit
simplement d’en créer un nouveau pour la nouvelle animation. Il faut alors
spécifier quel est le fichier BAP, le nombre d’images que comporte
l’animation ainsi que son nom.
-8-
4 INTERACTION
4.a Réseau
L’interaction ne se fait que dans un sens, en effet, il est possible en utilisant le
PDA de faire bouger le personnage virtuel sur un PC mais on ne peut faire
bouger le personnage du PDA depuis un PC. On peut dire que le Pocket PC
agit comme une télécommande. L’application a le rôle de client, tandis que le
PC aura celui de serveur.
Quelques difficultés on été rencontrées lors de l’implémentation de la partie
réseau. En premier lieu, c’est la librairie Winsock2 qui avait été utilisé.
Comme les tests se faisaient sur PC, cela ne posait aucun problème.
Cependant, des problèmes sont apparus lorsqu’il a fallu utiliser le réseau sur
le PDA. En effet, la librairie Winsock2 n’est pas disponible sur Pocket PC.
Seul la librairie Winsock permet d’accéder aux ressources réseau. Ces deux
librairies étant assez proches, il n’a pas été difficile de modifier le code
existant pour le rendre compatible avec Winsock.
Il est possible de connecter un Pocket PC à un réseau soit en utilisant une
carte réseau, soit en le branchant à un PC via un câble USB. Pour la dernière
possibilité, il faudra que le logiciel de synchronisation Miscrosoft ActiveSync
soit installé, c’est ce dernier qui fera la liaison entre le PDA et le réseau
auquel est branché le PC.
Pour que le PDA connaisse l’adresse du serveur auquel il doit se connecter
pour pouvoir interagir sur le personnage virtuel, un fichier ip.txt a été créé sur
le PDA. Dans ce fichier est écrit l’adresse IP du serveur ainsi que le port de
connexion. De cette manière, si l’adresse du serveur venait à changer, il
suffirait d’éditer ce fichier pour que le programme puisse retrouver le serveur.
4.b Protocole
Pour interagir avec le personnage virtuel depuis le PDA sur le PC, il a fallu
créer un protocole pour transférer les informations du mouvement. Les
messages de ce protocole sont de cette forme :
Num_Joint X Y Z
ou
16 angleA angleB
où Num_Joint représente un numéro entre 0 à 16 inclus. Les valeurs entre 0
et 15 représentent les différentes parties du corps. La valeur 16 indique la
caméra.
Les valeurs X, Y, Z, angleA et angleB sont en radians ; pour les joints, ils
représentent les valeurs des angle pour les axes x, y et z et pour la caméra ils
-9-
représentent les angles coordonnées polaires pour sa position. Voici la table
de correspondance entre les valeurs de Num_Joint et les parties du corps :
0
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
Tête
Torse
Ventre
Bassin
Bras Droit
Bras Gauche
Avant Bras Droit
Avant Bras Gauche
Main Droite
Main Gauche
Jambe Gauche
Jambe Droite
Mollet Gauche
Mollet Droite
Pied Droit
Pied Gauche
Voici un exemple de message envoyé :
12 2.4567 0.4556 0.0000
Durant une interaction, un message comme celui-ci est envoyé à chaque
image à travers le réseau.
Il faut noter que les messages envoyés ne respectent pas la spécification
MPEG-4 concernant l’animation de personnage. Il en a été décidé ainsi parce
que durant l’interaction, il n’est possible de bouger qu’un membre du corps à
la fois, il est alors inutile d’envoyer, comme le ferait la norme MPEG-4, des
informations concernant toutes les autres parties du corps si elles sont
identiques à l’image précédente.
- 10 -
5 PERFORMANCES
5.a Caractéristiques du PDA de Test
L’application a été testée sur deux modèles de Pocket PC différents. Pour le
premier, il s’agit de l’iPaq 3850 de marque Compaq dont voici les principales
caractéristiques [8] :
Processeur :
Mémoire :
Affichage :
Intel StrongARM à 206 MHz
64 MB RAM, 32 MB ROM
Ecran TFT, 240 x 320, 64K couleurs
Voici les caractéristiques du deuxième modèle, un iPaq 3950 de la même
marque [9] :
Processeur :
Mémoire :
Affichage :
Intel XScale à 400 MHz
64 MB RAM, 48 MB ROM
Ecran TFT, 240 x 320, 64K couleurs
5.b Analyse des Performances
Voici les performances en terme d’images par secondes qui ont été relevées
pendant les tests sur l’iPaq 3850 :
o Aucune interaction ni animation : ~17.8 fps
o Interaction
o réseau RJ45 : ~15.9 fps
o réseau USB : ~15.9 fps
o pas de réseau : ~16.2 fps
o Animation : ~16.8 fps
Et sur le 3950 :
o Aucune interaction ni animation : ~27 fps
o Interaction
o réseau RJ45 : ~21.1 fps
o réseau USB : ~20.7 fps
o pas de réseau : ~22.6 fps
o Animation : ~24.6 fps
- 11 -
Nous avons été surpris de voir que les performances étaient meilleures sur le
deuxième Pocket PC. Il s’agit certes d’un modèle plus récent et plus puissant
mais en ayant parcouru quelques sites sur internet [11], les performances pour
la librairie PocketGL étaient bien meilleures sur les processeurs de type
StrongARM que sur ceux de type XScale. Peut-être que cette librairie n’est
pas optimisée pour ces derniers processeurs. Cela permet de montrer que le
choix de la librairie Diesel Engine était un bon choix.
On peut constater que la différence de performances est plus importante sur le
deuxième PDA. Sur le premier modèle, l’écart maximal est de l’ordre de 11%
alors que sur le deuxième modèle, elle est de 23%.
Au final, on arrive à des performances qui varient entre 18 et 16 fps sur un
modèle et entre 27 et 20.7 fps sur l’autre, ce qui est suffisant pour une
application de ce type sur Pocket PC. Il peut toutefois paraître surprenant
d’avoir de si « faible » taux de rafraîchissement, avec des processeurs
respectivement à 200 et 400 MHz. Mais il ne faut pas oublier que ces
processeurs ne disposent pas d’unité spécifique pour le calcul de nombres à
virgules flottantes. Or, se sont ces calculs qui sont le plus utilisés dans les
applications 3D.
- 12 -
6 CONCLUSION
Ce projet a permis de rassembler plusieurs fonctionnalités, à savoir
l’interaction avec un personnage 3D, cette interaction étant ou non transféré à
un PC via le réseau afin d’y mettre à jour en temps réel un autre personnage
tournant sur une application du même type. Il est aussi possible dans la même
application de faire jouer au personnage différentes animations.
Bien évidement l’application finale n’est pas parfaite. Beaucoup
d’améliorations peuvent être encore faites sur beaucoup d’aspects :
o Il est pensable qu’un gain de performances pourrait être apporté en
optimisant le code. Ces gains permettraient d’avoir un modèle 3D
moins simpliste, il serait alors possible d’avoir un personnage avec
plus d’articulations, plus de détails dans le maillage 3D ou encore un
personnage texturé.
o L’interface graphique pourrait être améliorée afin de la rendre plus
intuitive pour les utilisateurs. Cela pourrait se faire par la création de
menus et de boutons. De tels ajouts permettraient par la même
occasion de réduire la taille de l’affichage 3D ce qui pourrait
augmenter légèrement la rapidité de l’application.
o Concernant la partie réseau, il serait aussi possible par la suite
d’implémenter une interaction dans l’autre sens, du PC au PDA.
o Une autre fonctionnalité pourrait être rajouté à ce projet, celle de faire
jouer une animation en même temps sur le PDA et sur le PC. Une des
difficultés étant de synchroniser l’animation entre les deux machines.
La différence de puissance entre un PC et un PDA étant énorme, il est
clair que le PC jouerait l’animation beaucoup plus rapidement que le
Pocket PC si des dispositions n’étaient pas prises pour empêcher cela.
On peut imaginer dans un futur proche, avec la montée en puissance des
Pocket PC, voir apparaître des jeux en 3D avec lesquels il serait possible de
jouer en réseau. Cela pourrait d’ailleurs faire le sujet d’un autre projet de
semestre : créer un jeu simple en 3D, à la manière de Doom par exemple, qui
permettrait à des personnes muni d’un Pocket PC de s’affronter en réseau.
- 13 -
7 APPENDICE
Dans cet appendice se trouve une brève description des classes et des fichiers
créés durant ce projet.
7.a Network.h
Ce ficher regroupe toutes les functions qui permettent d’utilisé le réseaux.
- void initSock();
Initialise un socket.
- SOCKET createSocket();
Créé un Socket.
- void assignPort(SOCKET s, int port);
Assigne le port port au socket s.
- void listen(SOCKET s);
Ecoute sur le socket s. Côté serveur.
- int connect(SOCKET s, char *adress, int port);
Se connecte sur le port port de la machine ayant l’adresse adress avec
le socket s. Côté client.
- SOCKET acceptConnexion(SOCKET s);
Accepte la connexion sur le socket s. Côté serveur.
- void write(SOCKET s, char *string);
Ecrire la chaîne de caractère string sur le socket s.
- int read(SOCKET s, char *buffer);
- void close(SOCKET s);
Ferme le socket s.
- 14 -
7.b Primities.h
Ce fichier regroupe des fonctions utilisées lors de la création de la géométrie
des différentes parties du personnage durant l’initialisation.
-
CDiesel3DVertexBuffer * CreateBoxTriangle(
-
CDiesel3DVertexBuffer * CreateHead( float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreateTorso(
float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreatePelvis(
float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreateUpLeg( float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreateLowLeg( float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreateBoxLine( float fXSize,
float fYSize,
float fZSize );
-
CDiesel3DVertexBuffer * CreateLowArm( float fXCentre,
float fYCentre,
float fZCentre );
-
CDiesel3DVertexBuffer * CreateUpArm(
-
CDiesel3DVertexBuffer * CreateHand(
-
CDiesel3DVertexBuffer * CreateFoot( float fXCentre,
float fYCentre,
float fZCentre );
- 15 -
float fXCentre,
float fYCentre,
float fZCentre );
float fXCentre,
float fYCentre,
float fZCentre );
float fXCentre,
float fYCentre,
float fZCentre );
7.c Class Surface1App
Class principale de l’application. C’est celle-ci qui gère l’animation,
l’interaction, la 3D, etc.
public:
-
SOCKET test;
char buffer[BUFFER_SIZE];
int port;
char adress[50];
int connexionError;
Différentes variables utilisé pour le réseau.
-
Obj charleston;
Obj walk;
Obj blast;
Obj boy;
Objets créés pour les animations.
-
CSurface1App();
virtual ~CSurface1App();
Construction et destruction.
-
void OnFlip();
Méthode de mise à jour.
-
DE_RETVAL OnInitDone();
void OnExit();
Méthodes utilisées lors de l’initialisation et de la clôture de
l’application.
-
void InitCamera();
Initialisation de la caméra.
-
void update_joint(int frame);
void update_joint_blast(int frame);
void update_joint_walk(int frame);
void update_joint_boy(int frame);
Méthodes permettant de mettre à jour l’image courante pour
l’animation. Il a été impossible d’utiliser une seule méthode
pour toutes les animations, le compilateur plantait lors de la
compilation.
-
CDiesel3DMaterial *redSurface;
CDiesel3DMaterial *selectedSurface;
Surfaces utilisées pour le personnage virtuel (rouge et jaune).
- 16 -
private:
-
CDieselWriter
m_Writer;
Utilisé pour écrire à l’écran.
-
CDieselInput
CDieselInputKeyboard
CDieselInputMouse
Utilisé pour les entrées.
-
float angleXZCam;
float angleYCam;
float rayonCam;
Paramètres du placement de la caméra (coordonnées polaire).
-
int
m_iXpos[3];
int
m_iYpos[3];
Position du stylet.
-
int
m_iXspeed[3];
int
m_iYspeed[3];
Vitesse de déplacement du stylet.
-
CDiesel3DObject * bodyParts[16];
Tableau d’objets pour les parties du corps.
CDieselVector3 bodyPartsPosition[16];
Tableau de vecteurs pour les orientations des membres du
corps.
float bodyPartsAngle[16][3];
Tableau d’angle pour les orientations des membres du corps
(utilisé uniquement durant l’interaction).
-
m_Input;
m_Keyboard;
m_Mouse;
-
CDieselSurface
m_srfPic[1];
Pour l’image en fond.
-
void bodyAfterAnim();
Cette méthode permet au personnage de reprendre la posture
qu’il avait avant de jouer une animation.
- 17 -
7.d Class Obj
Cette classe gère la lecture d’animation et son stockage en mémoire.
public:
- float BAP[300][37];
Tableau contenant les données de l’animation.
- char *name;
Nom de l’animation
- int nbFrame;
Nombre d’image dans l’animation.
- Obj();
Constructeur.
- int loadBAP(char *filename);
Cherger l’animation depuis le ficher filename dans le tableau BAP.
- 18 -
8 REFERENCES
[1]
Téléinformatique Sans Fil :
http://network.epfl.ch/tsf/
[2]
M. Gutiérrez, F. Vexo, D. Thalmann, A MPEG-4 Virtual Human Animation
Engine for Interactive Web Based Application. Proceedings of the 11th IEEE
International Workshop on Robot and Human Interactive Communication
(ROMAN 2002), September 2002, Berlin, Germany.
[3]
M. Gutiérrez, F. Vexo, D. Thalmann, Controlling Virtual Humans Using
PDAs. The 9th International Conference on Multi-Media Modeling (MMM'03),
January 7-10, 2003, Taiwan.
[4]
Diesel Engine :
http://www.inmarsoftware.com/
[5]
PocketGL :
http://pierrel5.free.fr/PocketGLb/ReadMeFirst.htm
[6]
Microsoft Visual C++ :
http://msdn.microsoft.com/visualc/
[7]
Microsoft eMbedded Visual C++ :
http://msdn.microsoft.com/vstudio/device/embedded/datasheet.aspx
[8]
Ipaq 3800 Series :
http://h20022.www2.hp.com/busprod/specifications/0,12513,series=96481%5Etype=64929%5E
category=215383,00.html?lsidebarLayId=79&rsidebarLayId=64
[9]
Ipaq 3900 Series :
http://www.compaq.fr/Produits/content/Fiche.asp?id=13477&p=5922&g=2277
[10] Microsoft Windows CE :
http://www.microsoft.com/windows/embedded/ce.net/default.asp
[11] Forum SundialSoft :
http://pub41.ezboard.com/fsundialsoftpocketpcfrm1
- 19 -